1. #include "stdafx.h"
2. #include <stack>
3. #include "utils.h"
4. #include "config.h"
5. #include "char.h"
6. #include "char_manager.h"
7. #include "item_manager.h"
8. #include "desc.h"
9. #include "desc_client.h"
10. #include "desc_manager.h"
11. #include "packet.h"
12. #include "affect.h"
13. #include "skill.h"
14. #include "start_position.h"
15. #include "mob_manager.h"
16. #include "db.h"
17. #include "log.h"
18. #include "vector.h"
19. #include "buffer_manager.h"
20. #include "questmanager.h"
21. #include "fishing.h"
22. #include "party.h"
23. #include "dungeon.h"
24. #include "refine.h"
25. #include "unique_item.h"
26. #include "war_map.h"
27. #include "xmas_event.h"
28. #include "marriage.h"
29. #include "monarch.h"
30. #ifdef NEW_PET_SYSTEM
31. #include "New_PetSystem.h"
32. #endif
33. #include "polymorph.h"
34. #include "blend_item.h"
35. #include "castle.h"
36. #include "BattleArena.h"
37. #include "arena.h"
38. #include "dev_log.h"
39. #include "pcbang.h"
40. #include "threeway_war.h"
42. #include "safebox.h"
43. #include "shop.h"
45. #include "../../common/VnumHelper.h"
46. #include "DragonSoul.h"
47. #include "buff_on_attributes.h"
48. #include "belt_inventory_helper.h"
50. //auction_temp
51. #ifdef __AUCTION__
52. #include "auction_manager.h"
53. #endif
54. const int ITEM_BROKEN_METIN_VNUM = 28960;
56. // CHANGE_ITEM_ATTRIBUTES
57. const DWORD CHARACTER::msc_dwDefaultChangeItemAttrCycle = 10;
58. const char CHARACTER::msc_szLastChangeItemAttrFlag[] = "Item.LastChangeItemAttr";
59. const char CHARACTER::msc_szChangeItemAttrCycleFlag[] = "change_itemattr_cycle";
60. // END_OF_CHANGE_ITEM_ATTRIBUTES
61. const BYTE g_aBuffOnAttrPoints[] = { POINT_ENERGY, POINT_COSTUME_ATTR_BONUS };
63. struct FFindStone
64. {
65. std::map<DWORD, LPCHARACTER> m_mapStone;
67. void operator()(LPENTITY pEnt)
68. {
69. if (pEnt->IsType(ENTITY_CHARACTER) == true)
70. {
71. LPCHARACTER pChar = (LPCHARACTER)pEnt;
73. if (pChar->IsStone() == true)
74. {
75. m_mapStone[(DWORD)pChar->GetVID()] = pChar;
76. }
77. }
78. }
79. };
82. //귀환부, 귀환기억부, 결혼반지
83. static bool IS_SUMMON_ITEM(int vnum)
84. {
85. switch (vnum)
86. {
87. case 22000:
88. case 22010:
89. case 22011:
90. case 22020:
91. case ITEM_MARRIAGE_RING:
92. return true;
93. }
95. return false;
96. }
98. static bool IS_MONKEY_DUNGEON(int map_index)
99. {
100. switch (map_index)
101. {
102. case 5:
103. case 25:
104. case 45:
105. case 108:
106. case 109:
107. return true;;
108. }
110. return false;
111. }
113. bool IS_SUMMONABLE_ZONE(int map_index)
114. {
115. // 몽키던전
116. if (IS_MONKEY_DUNGEON(map_index))
117. return false;
118. // 성
119. if (IS_CASTLE_MAP(map_index))
120. return false;
122. switch (map_index)
123. {
124. case 66 : // 사귀타워
125. case 71 : // 거미 던전 2층
126. case 72 : // 천의 동굴
127. case 73 : // 천의 동굴 2층
128. case 193 : // 거미 던전 2-1층
129. #if 0
130. case 184 : // 천의 동굴(신수)
131. case 185 : // 천의 동굴 2층(신수)
132. case 186 : // 천의 동굴(천조)
133. case 187 : // 천의 동굴 2층(천조)
134. case 188 : // 천의 동굴(진노)
135. case 189 : // 천의 동굴 2층(진노)
136. #endif
137. // case 206 : // 아귀동굴
138. case 216 : // 아귀동굴
139. case 217 : // 거미 던전 3층
140. case 208 : // 천의 동굴 (용방)
141. return false;
142. }
144. if (CBattleArena::IsBattleArenaMap(map_index)) return false;
146. // 모든 private 맵으론 워프 불가능
147. if (map_index > 10000) return false;
149. return true;
150. }
152. bool IS_BOTARYABLE_ZONE(int nMapIndex)
153. {
154. if (LC_IsYMIR() == false && LC_IsKorea() == false) return true;
156. switch (nMapIndex)
157. {
158. case 1 :
159. case 3 :
160. case 21 :
161. case 23 :
162. case 41 :
163. case 43 :
164. return true;
165. }
167. return false;
168. }
170. // item socket 이 프로토타입과 같은지 체크 -- by mhh
171. static bool FN_check_item_socket(LPITEM item)
172. {
173. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
174. {
175. if (item->GetSocket(i) != item->GetProto()->alSockets[i])
176. return false;
177. }
179. return true;
180. }
182. // item socket 복사 -- by mhh
183. static void FN_copy_item_socket(LPITEM dest, LPITEM src)
184. {
185. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
186. {
187. dest->SetSocket(i, src->GetSocket(i));
188. }
189. }
190. static bool FN_check_item_sex(LPCHARACTER ch, LPITEM item)
191. {
192. // 남자 금지
193. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_MALE))
194. {
195. if (SEX_MALE==GET_SEX(ch))
196. return false;
197. }
198. // 여자금지
199. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_FEMALE))
200. {
201. if (SEX_FEMALE==GET_SEX(ch))
202. return false;
203. }
205. return true;
206. }
209. /////////////////////////////////////////////////////////////////////////////
210. // ITEM HANDLING
211. /////////////////////////////////////////////////////////////////////////////
212. bool CHARACTER::CanHandleItem(bool bSkipCheckRefine, bool bSkipObserver)
213. {
214. if (!bSkipObserver)
215. if (m_bIsObserver)
216. return false;
218. if (GetMyShop())
219. return false;
221. if (!bSkipCheckRefine)
222. if (m_bUnderRefine)
223. return false;
225. if (IsCubeOpen() || NULL != DragonSoul_RefineWindow_GetOpener())
226. return false;
228. if (IsWarping())
229. return false;
231. #ifdef __SASH_SYSTEM__
232. if ((m_bSashCombination) || (m_bSashAbsorption))
233. return false;
234. #endif
236. return true;
237. }
239. LPITEM CHARACTER::GetInventoryItem(WORD wCell) const
240. {
241. return GetItem(TItemPos(INVENTORY, wCell));
242. }
243. LPITEM CHARACTER::GetItem(TItemPos Cell) const
244. {
245. if (!IsValidItemPosition(Cell))
246. return NULL;
247. WORD wCell = Cell.cell;
248. BYTE window_type = Cell.window_type;
249. switch (window_type)
250. {
251. case INVENTORY:
252. case EQUIPMENT:
253. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
254. {
255. sys_err("CHARACTER::GetInventoryItem: invalid item cell %d", wCell);
256. return NULL;
257. }
258. return m_pointsInstant.pItems[wCell];
259. case DRAGON_SOUL_INVENTORY:
260. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
261. {
262. sys_err("CHARACTER::GetInventoryItem: invalid DS item cell %d", wCell);
263. return NULL;
264. }
265. return m_pointsInstant.pDSItems[wCell];
267. default:
268. return NULL;
269. }
270. return NULL;
271. }
273. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem)
274. {
275. WORD wCell = Cell.cell;
276. BYTE window_type = Cell.window_type;
277. if ((unsigned long)((CItem*)pItem) == 0xff || (unsigned long)((CItem*)pItem) == 0xffffffff)
278. {
279. sys_err("!!! FATAL ERROR !!! item == 0xff (char: %s cell: %u)", GetName(), wCell);
280. core_dump();
281. return;
282. }
284. if (pItem && pItem->GetOwner())
285. {
286. assert(!"GetOwner exist");
287. return;
288. }
289. // 기본 인벤토리
290. switch(window_type)
291. {
292. case INVENTORY:
293. case EQUIPMENT:
294. {
295. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
296. {
297. sys_err("CHARACTER::SetItem: invalid item cell %d", wCell);
298. return;
299. }
301. LPITEM pOld = m_pointsInstant.pItems[wCell];
303. if (pOld)
304. {
305. if (wCell < INVENTORY_MAX_NUM)
306. {
307. for (int i = 0; i < pOld->GetSize(); ++i)
308. {
309. int p = wCell + (i * 5);
311. if (p >= INVENTORY_MAX_NUM)
312. continue;
314. if (m_pointsInstant.pItems[p] && m_pointsInstant.pItems[p] != pOld)
315. continue;
317. m_pointsInstant.bItemGrid[p] = 0;
318. }
319. }
320. else
321. m_pointsInstant.bItemGrid[wCell] = 0;
322. }
324. if (pItem)
325. {
326. if (wCell < INVENTORY_MAX_NUM)
327. {
328. for (int i = 0; i < pItem->GetSize(); ++i)
329. {
330. int p = wCell + (i * 5);
332. if (p >= INVENTORY_MAX_NUM)
333. continue;
335. // wCell + 1 로 하는 것은 빈곳을 체크할 때 같은
336. // 아이템은 예외처리하기 위함
337. m_pointsInstant.bItemGrid[p] = wCell + 1;
338. }
339. }
340. else
341. m_pointsInstant.bItemGrid[wCell] = wCell + 1;
342. }
344. m_pointsInstant.pItems[wCell] = pItem;
345. }
346. break;
347. // 용혼석 인벤토리
348. case DRAGON_SOUL_INVENTORY:
349. {
350. LPITEM pOld = m_pointsInstant.pDSItems[wCell];
352. if (pOld)
353. {
354. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
355. {
356. for (int i = 0; i < pOld->GetSize(); ++i)
357. {
358. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
360. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
361. continue;
363. if (m_pointsInstant.pDSItems[p] && m_pointsInstant.pDSItems[p] != pOld)
364. continue;
366. m_pointsInstant.wDSItemGrid[p] = 0;
367. }
368. }
369. else
370. m_pointsInstant.wDSItemGrid[wCell] = 0;
371. }
373. if (pItem)
374. {
375. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
376. {
377. sys_err("CHARACTER::SetItem: invalid DS item cell %d", wCell);
378. return;
379. }
381. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
382. {
383. for (int i = 0; i < pItem->GetSize(); ++i)
384. {
385. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
387. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
388. continue;
390. // wCell + 1 로 하는 것은 빈곳을 체크할 때 같은
391. // 아이템은 예외처리하기 위함
392. m_pointsInstant.wDSItemGrid[p] = wCell + 1;
393. }
394. }
395. else
396. m_pointsInstant.wDSItemGrid[wCell] = wCell + 1;
397. }
399. m_pointsInstant.pDSItems[wCell] = pItem;
400. }
401. break;
402. default:
403. sys_err ("Invalid Inventory type %d", window_type);
404. return;
405. }
407. if (GetDesc())
408. {
409. // 확장 아이템: 서버에서 아이템 플래그 정보를 보낸다
410. if (pItem)
411. {
412. TPacketGCItemSet pack;
413. pack.header = HEADER_GC_ITEM_SET;
414. pack.Cell = Cell;
416. pack.count = pItem->GetCount();
417. pack.vnum = pItem->GetVnum();
418. pack.flags = pItem->GetFlag();
419. pack.anti_flags = pItem->GetAntiFlag();
420. pack.highlight = (Cell.window_type == DRAGON_SOUL_INVENTORY);
423. thecore_memcpy(pack.alSockets, pItem->GetSockets(), sizeof(pack.alSockets));
424. thecore_memcpy(pack.aAttr, pItem->GetAttributes(), sizeof(pack.aAttr));
426. GetDesc()->Packet(&pack, sizeof(TPacketGCItemSet));
427. }
428. else
429. {
430. TPacketGCItemDelDeprecated pack;
431. pack.header = HEADER_GC_ITEM_DEL;
432. pack.Cell = Cell;
433. pack.count = 0;
434. pack.vnum = 0;
435. memset(pack.alSockets, 0, sizeof(pack.alSockets));
436. memset(pack.aAttr, 0, sizeof(pack.aAttr));
438. GetDesc()->Packet(&pack, sizeof(TPacketGCItemDelDeprecated));
439. }
440. }
442. if (pItem)
443. {
444. pItem->SetCell(this, wCell);
445. switch (window_type)
446. {
447. case INVENTORY:
448. case EQUIPMENT:
449. if ((wCell < INVENTORY_MAX_NUM) || (BELT_INVENTORY_SLOT_START <= wCell && BELT_INVENTORY_SLOT_END > wCell))
450. pItem->SetWindow(INVENTORY);
451. else
452. pItem->SetWindow(EQUIPMENT);
453. break;
454. case DRAGON_SOUL_INVENTORY:
455. pItem->SetWindow(DRAGON_SOUL_INVENTORY);
456. break;
457. }
458. }
459. }
461. LPITEM CHARACTER::GetWear(BYTE bCell) const
462. {
463. // > WEAR_MAX_NUM : 용혼석 슬롯들.
464. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
465. {
466. sys_err("CHARACTER::GetWear: invalid wear cell %d", bCell);
467. return NULL;
468. }
470. return m_pointsInstant.pItems[INVENTORY_MAX_NUM + bCell];
471. }
473. void CHARACTER::SetWear(BYTE bCell, LPITEM item)
474. {
475. // > WEAR_MAX_NUM : 용혼석 슬롯들.
476. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
477. {
478. sys_err("CHARACTER::SetItem: invalid item cell %d", bCell);
479. return;
480. }
482. SetItem(TItemPos (INVENTORY, INVENTORY_MAX_NUM + bCell), item);
484. if (!item && bCell == WEAR_WEAPON)
485. {
486. // 귀검 사용 시 벗는 것이라면 효과를 없애야 한다.
487. if (IsAffectFlag(AFF_GWIGUM))
488. RemoveAffect(SKILL_GWIGEOM);
490. if (IsAffectFlag(AFF_GEOMGYEONG))
491. RemoveAffect(SKILL_GEOMKYUNG);
492. }
493. }
495. void CHARACTER::ClearItem()
496. {
497. int i;
498. LPITEM item;
500. for (i = 0; i < INVENTORY_AND_EQUIP_SLOT_MAX; ++i)
501. {
502. if ((item = GetInventoryItem(i)))
503. {
504. item->SetSkipSave(true);
505. ITEM_MANAGER::instance().FlushDelayedSave(item);
507. item->RemoveFromCharacter();
508. M2_DESTROY_ITEM(item);
510. SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
511. }
512. }
513. for (i = 0; i < DRAGON_SOUL_INVENTORY_MAX_NUM; ++i)
514. {
515. if ((item = GetItem(TItemPos(DRAGON_SOUL_INVENTORY, i))))
516. {
517. item->SetSkipSave(true);
518. ITEM_MANAGER::instance().FlushDelayedSave(item);
520. item->RemoveFromCharacter();
521. M2_DESTROY_ITEM(item);
522. }
523. }
524. }
526. bool CHARACTER::IsEmptyItemGrid(TItemPos Cell, BYTE bSize, int iExceptionCell) const
527. {
528. switch (Cell.window_type)
529. {
530. case INVENTORY:
531. {
532. BYTE bCell = Cell.cell;
534. // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
535. // 따라서 iExceptionCell에 1을 더해 비교한다.
536. ++iExceptionCell;
538. if (Cell.IsBeltInventoryPosition())
539. {
540. LPITEM beltItem = GetWear(WEAR_BELT);
542. if (NULL == beltItem)
543. return false;
545. if (false == CBeltInventoryHelper::IsAvailableCell(bCell - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
546. return false;
548. if (m_pointsInstant.bItemGrid[bCell])
549. {
550. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
551. return true;
553. return false;
554. }
556. if (bSize == 1)
557. return true;
559. }
560. else if (bCell >= INVENTORY_MAX_NUM)
561. return false;
563. if (m_pointsInstant.bItemGrid[bCell])
564. {
565. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
566. {
567. if (bSize == 1)
568. return true;
570. int j = 1;
571. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 4);
573. do
574. {
575. BYTE p = bCell + (5 * j);
577. if (p >= INVENTORY_MAX_NUM)
578. return false;
580. if (p / (INVENTORY_MAX_NUM / 4) != bPage)
581. return false;
583. if (m_pointsInstant.bItemGrid[p])
584. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
585. return false;
586. }
587. while (++j < bSize);
589. return true;
590. }
591. else
592. return false;
593. }
595. // 크기가 1이면 한칸을 차지하는 것이므로 그냥 리턴
596. if (1 == bSize)
597. return true;
598. else
599. {
600. int j = 1;
601. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 4);
603. do
604. {
605. BYTE p = bCell + (5 * j);
607. if (p >= INVENTORY_MAX_NUM)
608. return false;
610. if (p / (INVENTORY_MAX_NUM / 4) != bPage)
611. return false;
613. if (m_pointsInstant.bItemGrid[p])
614. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
615. return false;
616. }
617. while (++j < bSize);
619. return true;
620. }
621. }
622. break;
623. case DRAGON_SOUL_INVENTORY:
624. {
625. WORD wCell = Cell.cell;
626. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
627. return false;
629. // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
630. // 따라서 iExceptionCell에 1을 더해 비교한다.
631. iExceptionCell++;
633. if (m_pointsInstant.wDSItemGrid[wCell])
634. {
635. if (m_pointsInstant.wDSItemGrid[wCell] == iExceptionCell)
636. {
637. if (bSize == 1)
638. return true;
640. int j = 1;
642. do
643. {
644. int p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
646. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
647. return false;
649. if (m_pointsInstant.wDSItemGrid[p])
650. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
651. return false;
652. }
653. while (++j < bSize);
655. return true;
656. }
657. else
658. return false;
659. }
661. // 크기가 1이면 한칸을 차지하는 것이므로 그냥 리턴
662. if (1 == bSize)
663. return true;
664. else
665. {
666. int j = 1;
668. do
669. {
670. int p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
672. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
673. return false;
675. if (m_pointsInstant.bItemGrid[p])
676. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
677. return false;
678. }
679. while (++j < bSize);
681. return true;
682. }
683. }
684. }
685. return false;
686. }
688. int CHARACTER::GetEmptyInventory(BYTE size) const
689. {
690. // NOTE: 현재 이 함수는 아이템 지급, 획득 등의 행위를 할 때 인벤토리의 빈 칸을 찾기 위해 사용되고 있는데,
691. // 벨트 인벤토리는 특수 인벤토리이므로 검사하지 않도록 한다. (기본 인벤토리: INVENTORY_MAX_NUM 까지만 검사)
692. for ( int i = 0; i < INVENTORY_MAX_NUM; ++i)
693. if (IsEmptyItemGrid(TItemPos (INVENTORY, i), size))
694. return i;
695. return -1;
696. }
698. int CHARACTER::GetEmptyDragonSoulInventory(LPITEM pItem) const
699. {
700. if (NULL == pItem || !pItem->IsDragonSoul())
701. return -1;
702. if (!DragonSoul_IsQualified())
703. {
704. return -1;
705. }
706. BYTE bSize = pItem->GetSize();
707. WORD wBaseCell = DSManager::instance().GetBasePosition(pItem);
709. if (WORD_MAX == wBaseCell)
710. return -1;
712. for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; ++i)
713. if (IsEmptyItemGrid(TItemPos(DRAGON_SOUL_INVENTORY, i + wBaseCell), bSize))
714. return i + wBaseCell;
716. return -1;
717. }
719. void CHARACTER::CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const
720. {
721. vDragonSoulItemGrid.resize(DRAGON_SOUL_INVENTORY_MAX_NUM);
723. std::copy(m_pointsInstant.wDSItemGrid, m_pointsInstant.wDSItemGrid + DRAGON_SOUL_INVENTORY_MAX_NUM, vDragonSoulItemGrid.begin());
724. }
726. int CHARACTER::CountEmptyInventory() const
727. {
728. int count = 0;
730. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
731. if (GetInventoryItem(i))
732. count += GetInventoryItem(i)->GetSize();
734. return (INVENTORY_MAX_NUM - count);
735. }
737. void TransformRefineItem(LPITEM pkOldItem, LPITEM pkNewItem)
738. {
739. // ACCESSORY_REFINE
740. if (pkOldItem->IsAccessoryForSocket())
741. {
742. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
743. {
744. pkNewItem->SetSocket(i, pkOldItem->GetSocket(i));
745. }
746. //pkNewItem->StartAccessorySocketExpireEvent();
747. }
748. // END_OF_ACCESSORY_REFINE
749. else
750. {
751. // 여기서 깨진석이 자동적으로 청소 됨
752. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
753. {
754. if (!pkOldItem->GetSocket(i))
755. break;
756. else
757. pkNewItem->SetSocket(i, 1);
758. }
760. // 소켓 설정
761. int slot = 0;
763. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
764. {
765. long socket = pkOldItem->GetSocket(i);
767. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
768. pkNewItem->SetSocket(slot++, socket);
769. }
771. }
773. // 매직 아이템 설정
774. pkOldItem->CopyAttributeTo(pkNewItem);
775. }
777. void NotifyRefineSuccess(LPCHARACTER ch, LPITEM item, const char* way)
778. {
779. if (NULL != ch && item != NULL)
780. {
781. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineSuceeded");
783. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), 1, way);
784. }
785. }
787. void NotifyRefineFail(LPCHARACTER ch, LPITEM item, const char* way, int success = 0)
788. {
789. if (NULL != ch && NULL != item)
790. {
791. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineFailed");
793. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), success, way);
794. }
795. }
797. void CHARACTER::SetRefineNPC(LPCHARACTER ch)
798. {
799. if ( ch != NULL )
800. {
801. m_dwRefineNPCVID = ch->GetVID();
802. }
803. else
804. {
805. m_dwRefineNPCVID = 0;
806. }
807. }
809. bool CHARACTER::DoRefine(LPITEM item, bool bMoneyOnly)
810. {
811. if (!CanHandleItem(true))
812. {
813. ClearRefineMode();
814. return false;
815. }
817. //개량 시간제한 : upgrade_refine_scroll.quest 에서 개량후 5분이내에 일반 개량을
818. //진행할수 없음
819. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
820. {
821. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
822. {
823. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
824. return false;
825. }
826. }
828. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
830. if (!prt)
831. return false;
833. DWORD result_vnum = item->GetRefinedVnum();
835. // REFINE_COST
836. int cost = ComputeRefineFee(prt->cost);
838. int RefineChance = GetQuestFlag("main_quest_lv7.refine_chance");
840. if (RefineChance > 0)
841. {
842. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
843. {
844. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무료 개량 기회는 20 이하의 무기만 가능합니다"));
845. return false;
846. }
848. cost = 0;
849. SetQuestFlag("main_quest_lv7.refine_chance", RefineChance - 1);
850. }
851. // END_OF_REFINE_COST
853. if (result_vnum == 0)
854. {
855. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 개량할 수 없습니다."));
856. return false;
857. }
859. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
860. return false;
862. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
864. if (!pProto)
865. {
866. sys_err("DoRefine NOT GET ITEM PROTO %d", item->GetRefinedVnum());
867. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
868. return false;
869. }
871. // Check level limit in korea only
872. if (!g_iUseLocale)
873. {
874. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
875. {
876. long limit = pProto->aLimits[i].lValue;
878. switch (pProto->aLimits[i].bType)
879. {
880. case LIMIT_LEVEL:
881. if (GetLevel() < limit)
882. {
883. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량된 후 아이템의 레벨 제한보다 레벨이 낮습니다."));
884. return false;
885. }
886. break;
887. }
888. }
889. }
891. // REFINE_COST
892. if (GetGold() < cost)
893. {
894. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 돈이 부족합니다."));
895. return false;
896. }
898. if (!bMoneyOnly && !RefineChance)
899. {
900. for (int i = 0; i < prt->material_count; ++i)
901. {
902. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
903. {
904. if (test_server)
905. {
906. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
907. }
908. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 재료가 부족합니다."));
909. return false;
910. }
911. }
913. for (int i = 0; i < prt->material_count; ++i)
914. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
915. }
917. int prob = number(1, 100);
919. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
920. if (IsRefineThroughGuild())
921. {
922. prob -= 10;
923. }
925. int success_prob = prt->prob;
926. success_prob += CRefineManager::instance().Result(this);
927. #else
928. if (IsRefineThroughGuild())
929. prob -= 10;
930. #endif
932. // END_OF_REFINE_COST
934. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
935. if (prob <= success_prob)
936. #else
937. if (prob <= prt->prob)
938. #endif
939. {
940. // 성공! 모든 아이템이 사라지고, 같은 속성의 다른 아이템 획득
941. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
943. if (pkNewItem)
944. {
945. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
946. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
948. BYTE bCell = item->GetCell();
950. // DETAIL_REFINE_LOG
951. NotifyRefineSuccess(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
952. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
953. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
954. // END_OF_DETAIL_REFINE_LOG
959. int m_nTableMin[] = {148, 158, 168, 1718, 188, 198};
960. int m_nTableMax[] = {149, 159, 169, 179, 189, 199};
962. for (int i = 0; i < _countof(m_nTableMin); i++){
963. for (int j = 0; j < _countof(m_nTableMax); j++){
964. if (m_nTableMin[i] <= pkNewItem->GetVnum() && pkNewItem->GetVnum() <= m_nTableMax[j]){
965. char buf[1024];
966. char itemlink[256];
967. int len;
969. len = snprintf(itemlink, sizeof(itemlink), "item:%x:%x:%x:%x:%x",
970. pkNewItem->GetVnum(), pkNewItem->GetFlag(),
971. pkNewItem->GetSocket(0), pkNewItem->GetSocket(1), pkNewItem->GetSocket(2));
973. for (int i = 0; i < ITEM_ATTRIBUTE_MAX_NUM; ++i)
974. if (pkNewItem->GetAttributeType(i) != 0){
975. len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%d",
976. pkNewItem->GetAttributeType(i), pkNewItem->GetAttributeValue(i));
977. }
979. snprintf(buf, sizeof(buf), "|cffffc700|H%s|h[%s]|h|r", itemlink, pkNewItem->GetName());
981. char szUpgradeAnnouncement[QUERY_MAX_LEN];
982. snprintf(szUpgradeAnnouncement, sizeof(szUpgradeAnnouncement), "<T2> [%s] a facut upgrade la %s cu succes!", GetName(), buf);
983. BroadcastNotice(szUpgradeAnnouncement);
984. break;
985. }
986. }
987. }
991. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
992. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
994. sys_log(0, "Refine Success %d", cost);
995. pkNewItem->AttrLog();
996. //PointChange(POINT_GOLD, -cost);
997. sys_log(0, "PayPee %d", cost);
998. PayRefineFee(cost);
999. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
1000. CRefineManager::instance().Reset(this);
1001. #endif
1002. sys_log(0, "PayPee End %d", cost);
1003. }
1004. else
1005. {
1006. // DETAIL_REFINE_LOG
1007. // 아이템 생성에 실패 -> 개량 실패로 간주
1008. sys_err("cannot create item %u", result_vnum);
1009. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
1010. // END_OF_DETAIL_REFINE_LOG
1011. }
1012. }
1013. else
1014. {
1015. // 실패! 모든 아이템이 사라짐.
1016. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
1017. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
1018. item->AttrLog();
1019. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
1021. //PointChange(POINT_GOLD, -cost);
1022. PayRefineFee(cost);
1023. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
1024. CRefineManager::instance().Reset(this);
1025. #endif
1026. }
1028. return true;
1029. }
1031. enum enum_RefineScrolls
1032. {
1033. CHUKBOK_SCROLL = 0,
1034. HYUNIRON_CHN = 1, // 중국에서만 사용
1035. YONGSIN_SCROLL = 2,
1036. MUSIN_SCROLL = 3,
1037. YAGONG_SCROLL = 4,
1038. MEMO_SCROLL = 5,
1039. BDRAGON_SCROLL = 6,
1040. };
1042. bool CHARACTER::DoRefineWithScroll(LPITEM item)
1043. {
1044. if (!CanHandleItem(true))
1045. {
1046. ClearRefineMode();
1047. return false;
1048. }
1050. ClearRefineMode();
1052. //개량 시간제한 : upgrade_refine_scroll.quest 에서 개량후 5분이내에 일반 개량을
1053. //진행할수 없음
1054. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
1055. {
1056. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
1057. {
1058. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
1059. return false;
1060. }
1061. }
1063. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
1065. if (!prt)
1066. return false;
1068. LPITEM pkItemScroll;
1070. // 개량서 체크
1071. if (m_iRefineAdditionalCell < 0)
1072. return false;
1074. pkItemScroll = GetInventoryItem(m_iRefineAdditionalCell);
1076. if (!pkItemScroll)
1077. return false;
1079. if (!(pkItemScroll->GetType() == ITEM_USE && pkItemScroll->GetSubType() == USE_TUNING))
1080. return false;
1082. if (pkItemScroll->GetVnum() == item->GetVnum())
1083. return false;
1085. DWORD result_vnum = item->GetRefinedVnum();
1086. DWORD result_fail_vnum = item->GetRefineFromVnum();
1088. if (result_vnum == 0)
1089. {
1090. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 개량할 수 없습니다."));
1091. return false;
1092. }
1094. // MUSIN_SCROLL
1095. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL)
1096. {
1097. if (item->GetRefineLevel() >= 4)
1098. {
1099. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 개량서로 더 이상 개량할 수 없습니다."));
1100. return false;
1101. }
1102. }
1103. // END_OF_MUSIC_SCROLL
1105. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
1106. {
1107. if (item->GetRefineLevel() != pkItemScroll->GetValue(1))
1108. {
1109. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 개량서로 개량할 수 없습니다."));
1110. return false;
1111. }
1112. }
1113. else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
1114. {
1115. if (item->GetType() != ITEM_METIN || item->GetRefineLevel() != 4)
1116. {
1117. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템으로 개량할 수 없습니다."));
1118. return false;
1119. }
1120. }
1122. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
1124. if (!pProto)
1125. {
1126. sys_err("DoRefineWithScroll NOT GET ITEM PROTO %d", item->GetRefinedVnum());
1127. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
1128. return false;
1129. }
1131. // Check level limit in korea only
1132. if (!g_iUseLocale)
1133. {
1134. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
1135. {
1136. long limit = pProto->aLimits[i].lValue;
1138. switch (pProto->aLimits[i].bType)
1139. {
1140. case LIMIT_LEVEL:
1141. if (GetLevel() < limit)
1142. {
1143. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량된 후 아이템의 레벨 제한보다 레벨이 낮습니다."));
1144. return false;
1145. }
1146. break;
1147. }
1148. }
1149. }
1151. if (GetGold() < prt->cost)
1152. {
1153. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 돈이 부족합니다."));
1154. return false;
1155. }
1157. for (int i = 0; i < prt->material_count; ++i)
1158. {
1159. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
1160. {
1161. if (test_server)
1162. {
1163. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
1164. }
1165. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 재료가 부족합니다."));
1166. return false;
1167. }
1168. }
1170. for (int i = 0; i < prt->material_count; ++i)
1171. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
1173. int prob = number(1, 100);
1174. int success_prob = prt->prob;
1175. bool bDestroyWhenFail = false;
1177. const char* szRefineType = "SCROLL";
1179. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN ||
1180. pkItemScroll->GetValue(0) == YONGSIN_SCROLL ||
1181. pkItemScroll->GetValue(0) == YAGONG_SCROLL) // 현철, 용신의 축복서, 야공의 비전서 처리
1182. {
1183. const char hyuniron_prob[9] = { 100, 75, 65, 55, 45, 40, 35, 25, 20 };
1184. const char hyuniron_prob_euckr[9] = { 100, 75, 65, 55, 45, 40, 35, 30, 25 };
1186. const char yagong_prob[9] = { 100, 100, 90, 80, 70, 60, 50, 30, 20 };
1187. const char yagong_prob_euckr[9] = { 100, 100, 90, 80, 70, 60, 50, 40, 30 };
1189. if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
1190. {
1191. success_prob = hyuniron_prob[MINMAX(0, item->GetRefineLevel(), 8)];
1192. }
1193. else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
1194. {
1195. success_prob = yagong_prob[MINMAX(0, item->GetRefineLevel(), 8)];
1196. }
1197. else if (pkItemScroll->GetValue(0) == HYUNIRON_CHN) {} // @fixme121
1198. else
1199. {
1200. sys_err("REFINE : Unknown refine scroll item. Value0: %d", pkItemScroll->GetValue(0));
1201. }
1203. if (test_server)
1204. {
1205. ChatPacket(CHAT_TYPE_INFO, "[Only Test] Success_Prob %d, RefineLevel %d ", success_prob, item->GetRefineLevel());
1206. }
1207. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN) // 현철은 아이템이 부서져야 한다.
1208. bDestroyWhenFail = true;
1210. // DETAIL_REFINE_LOG
1211. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
1212. {
1213. szRefineType = "HYUNIRON";
1214. }
1215. else if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
1216. {
1217. szRefineType = "GOD_SCROLL";
1218. }
1219. else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
1220. {
1221. szRefineType = "YAGONG_SCROLL";
1222. }
1223. // END_OF_DETAIL_REFINE_LOG
1224. }
1226. // DETAIL_REFINE_LOG
1227. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL) // 무신의 축복서는 100% 성공 (+4까지만)
1228. {
1229. success_prob = 100;
1231. szRefineType = "MUSIN_SCROLL";
1232. }
1233. // END_OF_DETAIL_REFINE_LOG
1234. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
1235. {
1236. success_prob = 100;
1237. szRefineType = "MEMO_SCROLL";
1238. }
1239. else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
1240. {
1241. success_prob = 80;
1242. szRefineType = "BDRAGON_SCROLL";
1243. }
1245. pkItemScroll->SetCount(pkItemScroll->GetCount() - 1);
1246. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
1247. success_prob += CRefineManager::instance().Result(this);
1248. #endif
1250. if (prob <= success_prob)
1251. {
1252. // 성공! 모든 아이템이 사라지고, 같은 속성의 다른 아이템 획득
1253. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
1255. if (pkNewItem)
1256. {
1257. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
1258. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
1260. BYTE bCell = item->GetCell();
1262. NotifyRefineSuccess(this, item, szRefineType);
1263. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
1264. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
1266. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
1267. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
1268. pkNewItem->AttrLog();
1269. //PointChange(POINT_GOLD, -prt->cost);
1270. PayRefineFee(prt->cost);
1271. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
1272. CRefineManager::instance().Reset(this);
1273. #endif
1274. }
1275. else
1276. {
1277. // 아이템 생성에 실패 -> 개량 실패로 간주
1278. sys_err("cannot create item %u", result_vnum);
1279. NotifyRefineFail(this, item, szRefineType);
1280. }
1281. }
1282. else if (!bDestroyWhenFail && result_fail_vnum)
1283. {
1284. // 실패! 모든 아이템이 사라지고, 같은 속성의 낮은 등급의 아이템 획득
1285. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_fail_vnum, 1, 0, false);
1287. if (pkNewItem)
1288. {
1289. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
1290. LogManager::instance().ItemLog(this, pkNewItem, "REFINE FAIL", pkNewItem->GetName());
1292. BYTE bCell = item->GetCell();
1294. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
1295. NotifyRefineFail(this, item, szRefineType, -1);
1296. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
1298. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
1299. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
1301. pkNewItem->AttrLog();
1303. //PointChange(POINT_GOLD, -prt->cost);
1304. PayRefineFee(prt->cost);
1305. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
1306. CRefineManager::instance().Reset(this);
1307. #endif
1308. }
1309. else
1310. {
1311. // 아이템 생성에 실패 -> 개량 실패로 간주
1312. sys_err("cannot create item %u", result_fail_vnum);
1313. NotifyRefineFail(this, item, szRefineType);
1314. }
1315. }
1316. else
1317. {
1318. NotifyRefineFail(this, item, szRefineType); // 개량시 아이템 사라지지 않음
1320. PayRefineFee(prt->cost);
1321. #ifdef ENABLE_FEATURES_REFINE_SYSTEM
1322. CRefineManager::instance().Reset(this);
1323. #endif
1324. }
1326. return true;
1327. }
1329. bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell)
1330. {
1331. if (bCell > INVENTORY_MAX_NUM)
1332. return false;
1334. LPITEM item = GetInventoryItem(bCell);
1336. if (!item)
1337. return false;
1339. // REFINE_COST
1340. if (bType == REFINE_TYPE_MONEY_ONLY && !GetQuestFlag("deviltower_zone.can_refine"))
1341. {
1342. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사귀 타워 완료 보상은 한번까지 사용가능합니다."));
1343. return false;
1344. }
1345. // END_OF_REFINE_COST
1347. TPacketGCRefineInformation p;
1349. p.header = HEADER_GC_REFINE_INFORMATION;
1350. p.pos = bCell;
1351. p.src_vnum = item->GetVnum();
1352. p.result_vnum = item->GetRefinedVnum();
1353. p.type = bType;
1355. if (p.result_vnum == 0)
1356. {
1357. sys_err("RefineInformation p.result_vnum == 0");
1358. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
1359. return false;
1360. }
1362. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
1363. {
1364. if (bType == 0)
1365. {
1366. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 이 방식으로는 개량할 수 없습니다."));
1367. return false;
1368. }
1369. else
1370. {
1371. LPITEM itemScroll = GetInventoryItem(iAdditionalCell);
1372. if (!itemScroll || item->GetVnum() == itemScroll->GetVnum())
1373. {
1374. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 개량서를 합칠 수는 없습니다."));
1375. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("축복의 서와 현철을 합칠 수 있습니다."));
1376. return false;
1377. }
1378. }
1379. }
1381. CRefineManager & rm = CRefineManager::instance();
1383. const TRefineTable* prt = rm.GetRefineRecipe(item->GetRefineSet());
1385. if (!prt)
1386. {
1387. sys_err("RefineInformation NOT GET REFINE SET %d", item->GetRefineSet());
1388. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
1389. return false;
1390. }
1392. // REFINE_COST
1394. //MAIN_QUEST_LV7
1395. if (GetQuestFlag("main_quest_lv7.refine_chance") > 0)
1396. {
1397. // 일본은 제외
1398. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
1399. {
1400. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무료 개량 기회는 20 이하의 무기만 가능합니다"));
1401. return false;
1402. }
1403. p.cost = 0;
1404. }
1405. else
1406. p.cost = ComputeRefineFee(prt->cost);
1408. //END_MAIN_QUEST_LV7
1409. p.prob = prt->prob;
1410. if (bType == REFINE_TYPE_MONEY_ONLY)
1411. {
1412. p.material_count = 0;
1413. memset(p.materials, 0, sizeof(p.materials));
1414. }
1415. else
1416. {
1417. p.material_count = prt->material_count;
1418. thecore_memcpy(&p.materials, prt->materials, sizeof(prt->materials));
1419. }
1420. // END_OF_REFINE_COST
1422. GetDesc()->Packet(&p, sizeof(TPacketGCRefineInformation));
1424. SetRefineMode(iAdditionalCell);
1425. return true;
1426. }
1428. bool CHARACTER::RefineItem(LPITEM pkItem, LPITEM pkTarget)
1429. {
1430. if (!CanHandleItem())
1431. return false;
1433. if (pkItem->GetSubType() == USE_TUNING)
1434. {
1435. // XXX 성능, 소켓 개량서는 사라졌습니다...
1436. // XXX 성능개량서는 축복의 서가 되었다!
1437. // MUSIN_SCROLL
1438. if (pkItem->GetValue(0) == MUSIN_SCROLL)
1439. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_MUSIN, pkItem->GetCell());
1440. // END_OF_MUSIN_SCROLL
1441. else if (pkItem->GetValue(0) == HYUNIRON_CHN)
1442. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_HYUNIRON, pkItem->GetCell());
1443. else if (pkItem->GetValue(0) == BDRAGON_SCROLL)
1444. {
1445. if (pkTarget->GetRefineSet() != 702) return false;
1446. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_BDRAGON, pkItem->GetCell());
1447. }
1448. else
1449. {
1450. if (pkTarget->GetRefineSet() == 501) return false;
1451. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SCROLL, pkItem->GetCell());
1452. }
1453. }
1454. else if (pkItem->GetSubType() == USE_DETACHMENT && IS_SET(pkTarget->GetFlag(), ITEM_FLAG_REFINEABLE))
1455. {
1456. LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
1458. bool bHasMetinStone = false;
1460. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)
1461. {
1462. long socket = pkTarget->GetSocket(i);
1463. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
1464. {
1465. bHasMetinStone = true;
1466. break;
1467. }
1468. }
1470. if (bHasMetinStone)
1471. {
1472. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
1473. {
1474. long socket = pkTarget->GetSocket(i);
1475. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
1476. {
1477. AutoGiveItem(socket);
1478. //TItemTable* pTable = ITEM_MANAGER::instance().GetTable(pkTarget->GetSocket(i));
1479. //pkTarget->SetSocket(i, pTable->alValues[2]);
1480. // 깨진돌로 대체해준다
1481. pkTarget->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
1482. }
1483. }
1484. pkItem->SetCount(pkItem->GetCount() - 1);
1485. return true;
1486. }
1487. else
1488. {
1489. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 수 있는 메틴석이 없습니다."));
1490. return false;
1491. }
1492. }
1494. return false;
1495. }
1497. EVENTFUNC(kill_campfire_event)
1498. {
1499. char_event_info* info = dynamic_cast<char_event_info*>( event->info );
1501. if ( info == NULL )
1502. {
1503. sys_err( "kill_campfire_event> <Factor> Null pointer" );
1504. return 0;
1505. }
1507. LPCHARACTER ch = info->ch;
1509. if (ch == NULL) { // <Factor>
1510. return 0;
1511. }
1512. ch->m_pkMiningEvent = NULL;
1513. M2_DESTROY_CHARACTER(ch);
1514. return 0;
1515. }
1517. bool CHARACTER::GiveRecallItem(LPITEM item)
1518. {
1519. int idx = GetMapIndex();
1520. int iEmpireByMapIndex = -1;
1522. if (idx < 20)
1523. iEmpireByMapIndex = 1;
1524. else if (idx < 40)
1525. iEmpireByMapIndex = 2;
1526. else if (idx < 60)
1527. iEmpireByMapIndex = 3;
1528. else if (idx < 10000)
1529. iEmpireByMapIndex = 0;
1531. switch (idx)
1532. {
1533. case 66:
1534. case 216:
1535. iEmpireByMapIndex = -1;
1536. break;
1537. }
1539. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
1540. {
1541. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("기억해 둘 수 없는 위치 입니다."));
1542. return false;
1543. }
1545. int pos;
1547. if (item->GetCount() == 1) // 아이템이 하나라면 그냥 셋팅.
1548. {
1549. item->SetSocket(0, GetX());
1550. item->SetSocket(1, GetY());
1551. }
1552. else if ((pos = GetEmptyInventory(item->GetSize())) != -1) // 그렇지 않다면 다른 인벤토리 슬롯을 찾는다.
1553. {
1554. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), 1);
1556. if (NULL != item2)
1557. {
1558. item2->SetSocket(0, GetX());
1559. item2->SetSocket(1, GetY());
1560. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
1562. item->SetCount(item->GetCount() - 1);
1563. }
1564. }
1565. else
1566. {
1567. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
1568. return false;
1569. }
1571. return true;
1572. }
1574. void CHARACTER::ProcessRecallItem(LPITEM item)
1575. {
1576. int idx;
1578. if ((idx = SECTREE_MANAGER::instance().GetMapIndex(item->GetSocket(0), item->GetSocket(1))) == 0)
1579. return;
1581. int iEmpireByMapIndex = -1;
1583. if (idx < 20)
1584. iEmpireByMapIndex = 1;
1585. else if (idx < 40)
1586. iEmpireByMapIndex = 2;
1587. else if (idx < 60)
1588. iEmpireByMapIndex = 3;
1589. else if (idx < 10000)
1590. iEmpireByMapIndex = 0;
1592. switch (idx)
1593. {
1594. case 66:
1595. case 216:
1596. iEmpireByMapIndex = -1;
1597. break;
1598. // 악룡군도 일때
1599. case 301:
1600. case 302:
1601. case 303:
1602. case 304:
1603. if( GetLevel() < 90 )
1604. {
1605. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템의 레벨 제한보다 레벨이 낮습니다."));
1606. return;
1607. }
1608. else
1609. break;
1610. }
1612. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
1613. {
1614. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("기억된 위치가 타제국에 속해 있어서 귀환할 수 없습니다."));
1615. item->SetSocket(0, 0);
1616. item->SetSocket(1, 0);
1617. }
1618. else
1619. {
1620. sys_log(1, "Recall: %s %d %d -> %d %d", GetName(), GetX(), GetY(), item->GetSocket(0), item->GetSocket(1));
1621. WarpSet(item->GetSocket(0), item->GetSocket(1));
1622. item->SetCount(item->GetCount() - 1);
1623. }
1624. }
1626. void CHARACTER::__OpenPrivateShop()
1627. {
1628. unsigned bodyPart = GetPart(PART_MAIN);
1629. switch (bodyPart)
1630. {
1631. case 0:
1632. case 1:
1633. case 2:
1634. ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
1635. break;
1636. default:
1637. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("갑옷을 벗어야 개인 상점을 열 수 있습니다."));
1638. break;
1639. }
1640. }
1642. // MYSHOP_PRICE_LIST
1643. void CHARACTER::SendMyShopPriceListCmd(DWORD dwItemVnum, long long dwItemPrice)
1644. {
1645. char szLine[256];
1646. snprintf(szLine, sizeof(szLine), "MyShopPriceList %u %lld", dwItemVnum, dwItemPrice);
1647. ChatPacket(CHAT_TYPE_COMMAND, szLine);
1648. sys_log(0, szLine);
1649. }
1651. //
1652. // DB 캐시로 부터 받은 리스트를 User 에게 전송하고 상점을 열라는 커맨드를 보낸다.
1653. //
1654. void CHARACTER::UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p)
1655. {
1656. const TItemPriceInfo* pInfo = (const TItemPriceInfo*)(p + 1);
1658. if (!p->byCount)
1659. // 가격 리스트가 없다. dummy 데이터를 넣은 커맨드를 보내준다.
1660. SendMyShopPriceListCmd(1, 0);
1661. else {
1662. for (int idx = 0; idx < p->byCount; idx++)
1663. SendMyShopPriceListCmd(pInfo[ idx ].dwVnum, pInfo[ idx ].dwPrice);
1664. }
1666. __OpenPrivateShop();
1667. }
1669. //
1670. // 이번 접속 후 처음 상점을 Open 하는 경우 리스트를 Load 하기 위해 DB 캐시에 가격정보 리스트 요청 패킷을 보낸다.
1671. // 이후부터는 바로 상점을 열라는 응답을 보낸다.
1672. //
1673. void CHARACTER::UseSilkBotary(void)
1674. {
1675. if (m_bNoOpenedShop) {
1676. DWORD dwPlayerID = GetPlayerID();
1677. db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_REQ, GetDesc()->GetHandle(), &dwPlayerID, sizeof(DWORD));
1678. m_bNoOpenedShop = false;
1679. } else {
1680. __OpenPrivateShop();
1681. }
1682. }
1683. // END_OF_MYSHOP_PRICE_LIST
1685. int CalculateConsume(LPCHARACTER ch)
1686. {
1687. static const int WARP_NEED_LIFE_PERCENT = 30;
1688. static const int WARP_MIN_LIFE_PERCENT = 10;
1689. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
1690. int consumeLife = 0;
1691. {
1692. // CheckNeedLifeForWarp
1693. const int curLife = ch->GetHP();
1694. const int needPercent = WARP_NEED_LIFE_PERCENT;
1695. const int needLife = ch->GetMaxHP() * needPercent / 100;
1696. if (curLife < needLife)
1697. {
1698. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("남은 생명력 양이 모자라 사용할 수 없습니다."));
1699. return -1;
1700. }
1702. consumeLife = needLife;
1705. // CheckMinLifeForWarp: 독에 의해서 죽으면 안되므로 생명력 최소량는 남겨준다
1706. const int minPercent = WARP_MIN_LIFE_PERCENT;
1707. const int minLife = ch->GetMaxHP() * minPercent / 100;
1708. if (curLife - needLife < minLife)
1709. consumeLife = curLife - minLife;
1711. if (consumeLife < 0)
1712. consumeLife = 0;
1713. }
1714. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
1715. return consumeLife;
1716. }
1718. int CalculateConsumeSP(LPCHARACTER lpChar)
1719. {
1720. static const int NEED_WARP_SP_PERCENT = 30;
1722. const int curSP = lpChar->GetSP();
1723. const int needSP = lpChar->GetMaxSP() * NEED_WARP_SP_PERCENT / 100;
1725. if (curSP < needSP)
1726. {
1727. lpChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("남은 정신력 양이 모자라 사용할 수 없습니다."));
1728. return -1;
1729. }
1731. return needSP;
1732. }
1734. #ifdef ENABLE_YMIR_AFFECT_FIX
1735. bool CHARACTER::CheckTimeUsed(LPITEM item)
1736. {
1737. switch (item->GetVnum())
1738. {
1739. /****************
1740. * Type = 27 -> ITEM_BLEND (Delete the other case you do not want for check)
1741. */
1742. case 50821: case 50822: case 50823: case 50824: case 50825: case 50826:
1743. case 50813: case 50814: case 50815: case 50816: case 50817: case 50818:
1744. case 50819: case 50820: case 27866: case 27868: case 27870: case 27873:
1745. case 39026: case 50093: case 50094: case 50123: case 50801: case 50802:
1746. case 39010: case 39017: case 39018: case 39019: case 39020: case 39024:
1747. case 39025: case 39031: case 71014: case 71015: case 71016: case 71017:
1748. case 71027: case 71028: case 71029: case 71030: case 71034: case 71044:
1749. case 71045: case 71101: case 71102: case 71153: case 71154: case 71155:
1750. case 71156: case 72025: case 72026: case 72027: case 72031: case 72032:
1751. case 72033: case 72034: case 72035: case 72036: case 72037: case 76018:
1752. case 72038: case 72039: case 72040: case 72041: case 72042: case 72046:
1753. case 72047: case 72048: case 72312: case 72313: case 72501: case 72502:
1755. int pGetTime[] = {5}; // Set timer for how you need a long after you login for can use item
1757. int pGetFlag = GetQuestFlag("item.last_time"); // Get questflag where him set from input_login.cpp (Not change)
1759. const char* pGetMessage[] = {"|cFFd0ffcc|H|hYou cannot use |cFFc9ff00|H|h[%s] |cFFd0ffcc|H|honly after passing |cFFec03e2|H|h[%u] |cFFd0ffcc|H|hseconds of logging!"}; // Get message when you use time so fast
1761. if (pGetFlag) // Initializate questflag on item
1762. {
1763. if (get_global_time() < pGetFlag + pGetTime[0]) // Initializate to get a + second for questflag
1764. {
1765. ChatPacket(CHAT_TYPE_INFO, pGetMessage[0], item->GetName(), pGetTime[0]); // Get message
1766. return false; // Returns false if you use the item quicker than those seconds
1767. }
1768. }
1769. break;
1770. }
1771. return true;
1772. }
1773. #endif
1775. bool CHARACTER::UseItemEx(LPITEM item, TItemPos DestCell)
1776. {
1777. int iLimitRealtimeStartFirstUseFlagIndex = -1;
1778. int iLimitTimerBasedOnWearFlagIndex = -1;
1780. WORD wDestCell = DestCell.cell;
1781. BYTE bDestInven = DestCell.window_type;
1782. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
1783. {
1784. long limitValue = item->GetProto()->aLimits[i].lValue;
1786. switch (item->GetProto()->aLimits[i].bType)
1787. {
1788. case LIMIT_LEVEL:
1789. if (GetLevel() < limitValue)
1790. {
1791. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템의 레벨 제한보다 레벨이 낮습니다."));
1792. return false;
1793. }
1794. break;
1796. case LIMIT_REAL_TIME_START_FIRST_USE:
1797. iLimitRealtimeStartFirstUseFlagIndex = i;
1798. break;
1800. case LIMIT_TIMER_BASED_ON_WEAR:
1801. iLimitTimerBasedOnWearFlagIndex = i;
1802. break;
1803. }
1804. }
1806. if (test_server)
1807. {
1808. //sys_log(0, "USE_ITEM %s, Inven %d, Cell %d, ItemType %d, SubType %d", item->GetName(), bDestInven, wDestCell, item->GetType(), item->GetSubType());
1809. }
1811. if ( CArenaManager::instance().IsLimitedItem( GetMapIndex(), item->GetVnum() ) == true )
1812. {
1813. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
1814. return false;
1815. }
1817. // @fixme141 BEGIN
1818. if (TItemPos(item->GetWindow(), item->GetCell()).IsBeltInventoryPosition())
1819. {
1820. LPITEM beltItem = GetWear(WEAR_BELT);
1822. if (NULL == beltItem)
1823. {
1824. ChatPacket(CHAT_TYPE_INFO, "<Belt> You can't use this item if you have no equipped belt.");
1825. return false;
1826. }
1828. if (false == CBeltInventoryHelper::IsAvailableCell(item->GetCell() - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
1829. {
1830. ChatPacket(CHAT_TYPE_INFO, "<Belt> You can't use this item if you don't upgrade your belt.");
1831. return false;
1832. }
1833. }
1834. // @fixme141 END
1836. // 아이템 최초 사용 이후부터는 사용하지 않아도 시간이 차감되는 방식 처리.
1837. if (item->GetVnum() == 55009)
1838. {
1839. int number1461 = number(55010,55027);//item kodları
1840. AutoGiveItem(number1461);
1841. item->SetCount(item->GetCount() - 1);
1842. }
1843. if (-1 != iLimitRealtimeStartFirstUseFlagIndex)
1844. {
1845. // 한 번이라도 사용한 아이템인지 여부는 Socket1을 보고 판단한다. (Socket1에 사용횟수 기록)
1846. if (0 == item->GetSocket(1))
1847. {
1848. // 사용가능시간은 Default 값으로 Limit Value 값을 사용하되, Socket0에 값이 있으면 그 값을 사용하도록 한다. (단위는 초)
1849. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[iLimitRealtimeStartFirstUseFlagIndex].lValue;
1851. if (0 == duration)
1852. duration = 60 * 60 * 24 * 7;
1854. item->SetSocket(0, time(0) + duration);
1855. item->StartRealTimeExpireEvent();
1856. }
1858. if (false == item->IsEquipped())
1859. item->SetSocket(1, item->GetSocket(1) + 1);
1860. }
1861. #ifdef NEW_PET_SYSTEM
1862. if (item->GetVnum() == 55001) {
1864. LPITEM item2;
1866. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
1867. return false;
1869. if (item2->IsExchanging())
1870. return false;
1872. if (item2->GetVnum() >= 55718 || item2->GetVnum() < 55701)
1873. return false;
1876. char szQuery1[1024];
1877. snprintf(szQuery1, sizeof(szQuery1), "SELECT duration FROM new_petsystem WHERE id = %lu LIMIT 1", item2->GetID());
1878. std::auto_ptr<SQLMsg> pmsg2(DBManager::instance().DirectQuery(szQuery1));
1879. if (pmsg2->Get()->uiNumRows > 0) {
1880. MYSQL_ROW row = mysql_fetch_row(pmsg2->Get()->pSQLResult);
1881. if (atoi(row[0]) > 0) {
1882. if (GetNewPetSystem()->IsActivePet()) {
1883. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You have to unsummon your pet first."));
1884. return false;
1885. }
1887. DBManager::instance().DirectQuery("UPDATE new_petsystem SET duration =(tduration) WHERE id = %d", item2->GetID());
1888. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Your Pet's life is now full."));
1889. }
1890. else {
1891. DBManager::instance().DirectQuery("UPDATE new_petsystem SET duration =(tduration/2) WHERE id = %d", item2->GetID());
1892. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Your Pet's life is now restored."));
1893. }
1894. item->SetCount(item->GetCount() - 1);
1895. return true;
1896. }
1897. else
1898. return false;
1899. }
1901. if (item->GetVnum() >= 55701 && item->GetVnum() <= 55718)
1902. {
1903. LPITEM item2;
1905. if (item2 = GetItem(DestCell)) {
1906. if (item2->GetVnum() == 55002)
1907. {
1908. if(item2->GetAttributeValue(0) > 0)
1909. {
1910. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Cutia are deja un animalut inauntru."));
1911. }
1912. else if (item->GetAttributeValue(3) == 0)
1913. {
1914. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("bu_halde_konulamaz."));
1915. return false;
1916. }
1917. else
1918. {
1919. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
1920. return false;
1922. if (item2->IsExchanging())
1923. return false;
1925. if (GetNewPetSystem()->IsActivePet())
1926. {
1927. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You have to unsummon your pet first."));
1928. return false;
1929. }
1931. for (int b = 0; b < 3; b++)
1932. {
1933. item2->SetForceAttribute(b, 1, item->GetAttributeValue(b));
1934. }
1936. item2->SetForceAttribute(3, 1, item->GetAttributeValue(3));
1937. item2->SetForceAttribute(4, 1, item->GetAttributeValue(4));
1938. //Pet Yas Bugu Fixi//
1939. item2->SetForceAttribute(5, 1, item->GetAttributeValue(5));
1940. //Pet Yas Bugu Fixi//
1941. DWORD vnum1 = item->GetVnum()-55700;
1942. item2->SetSocket(2, vnum1);
1943. item2->SetSocket(1, item->GetSocket(1));
1944. //ChatPacket(CHAT_TYPE_INFO, "Pet %d %d %d //// %d %d %d",item->GetAttributeValue(0),item->GetAttributeValue(1),item->GetAttributeValue(2),item2->GetAttributeValue(0),item2->GetAttributeValue(1),item2->GetAttributeValue(2));
1945. DBManager::instance().DirectQuery("UPDATE new_petsystem SET id =%d WHERE id = %d", item2->GetID(), item->GetID());
1946. ITEM_MANAGER::instance().RemoveItem(item);
1947. return true;
1948. }
1949. }
1950. }
1951. }
1954. if (item->GetVnum() == 55002 && item->GetAttributeValue(0) > 0) {
1956. int pos = GetEmptyInventory(item->GetSize());
1957. if(pos == -1)
1958. {
1959. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nu ai destul spatiu in inventar!"));
1960. return false;
1961. }
1963. if (GetLevel() < item->GetSocket(1))
1964. {
1965. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nivelul animalutului mai mare decat nivelul tau"));
1966. return false;
1967. }
1969. if (item->IsExchanging())
1970. return false;
1971. DWORD vnum2 = 55700+item->GetSocket(2);
1972. LPITEM item2 = AutoGiveItem(vnum2, 1);
1973. for (int b = 0; b < 3; b++) {
1974. item2->SetForceAttribute(b, 1, item->GetAttributeValue(b));
1975. }
1976. item2->SetForceAttribute(3, 1, item->GetAttributeValue(3));
1977. item2->SetForceAttribute(4, 1, item->GetAttributeValue(4));
1978. //Pet Yas Bugu Fixi//
1979. item2->SetForceAttribute(5, 1, item->GetAttributeValue(5));
1980. //Pet Yas Bugu Fixi//
1981. item2->SetSocket(1,item->GetSocket(1));
1982. //ChatPacket(CHAT_TYPE_INFO, "Pet1 %d %d %d",item->GetAttributeValue(0),item->GetAttributeValue(1),item->GetAttributeValue(2));
1983. DBManager::instance().DirectQuery("UPDATE new_petsystem SET id =%d WHERE id = %d", item2->GetID(), item->GetID());
1984. ITEM_MANAGER::instance().RemoveItem(item);
1985. return true;
1987. }
1988. #endif
1990. switch (item->GetType())
1991. {
1992. case ITEM_HAIR:
1993. return ItemProcess_Hair(item, wDestCell);
1995. case ITEM_POLYMORPH:
1996. return ItemProcess_Polymorph(item);
1998. case ITEM_QUEST:
1999. if (GetArena() != NULL || IsObserverMode() == true)
2000. {
2001. if (item->GetVnum() == 50051 || item->GetVnum() == 50052 || item->GetVnum() == 50053)
2002. {
2003. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
2004. return false;
2005. }
2006. }
2008. if (!IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE | ITEM_FLAG_QUEST_USE_MULTIPLE))
2009. {
2010. if (item->GetSIGVnum() == 0)
2011. {
2012. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
2013. }
2014. else
2015. {
2016. quest::CQuestManager::instance().SIGUse(GetPlayerID(), item->GetSIGVnum(), item, false);
2017. }
2018. }
2019. break;
2021. case ITEM_CAMPFIRE:
2022. {
2023. float fx, fy;
2024. GetDeltaByDegree(GetRotation(), 100.0f, &fx, &fy);
2026. LPSECTREE tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy));
2028. if (!tree)
2029. {
2030. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("모닥불을 피울 수 없는 지점입니다."));
2031. return false;
2032. }
2034. if (tree->IsAttr((long)(GetX()+fx), (long)(GetY()+fy), ATTR_WATER))
2035. {
2036. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물 속에 모닥불을 피울 수 없습니다."));
2037. return false;
2038. }
2040. LPCHARACTER campfire = CHARACTER_MANAGER::instance().SpawnMob(fishing::CAMPFIRE_MOB, GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy), 0, false, number(0, 359));
2042. char_event_info* info = AllocEventInfo<char_event_info>();
2044. info->ch = campfire;
2046. campfire->m_pkMiningEvent = event_create(kill_campfire_event, info, PASSES_PER_SEC(40));
2048. item->SetCount(item->GetCount() - 1);
2049. }
2050. break;
2052. case ITEM_UNIQUE:
2053. {
2054. switch (item->GetSubType())
2055. {
2056. case USE_ABILITY_UP:
2057. {
2058. switch (item->GetValue(0))
2059. {
2060. case APPLY_MOV_SPEED:
2061. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true, true);
2062. break;
2064. case APPLY_ATT_SPEED:
2065. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true, true);
2066. break;
2068. case APPLY_STR:
2069. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2070. break;
2072. case APPLY_DEX:
2073. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2074. break;
2076. case APPLY_CON:
2077. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2078. break;
2080. case APPLY_INT:
2081. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2082. break;
2084. case APPLY_CAST_SPEED:
2085. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2086. break;
2088. case APPLY_RESIST_MAGIC:
2089. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_RESIST_MAGIC, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2090. break;
2092. case APPLY_ATT_GRADE_BONUS:
2093. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_GRADE_BONUS,
2094. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2095. break;
2097. case APPLY_DEF_GRADE_BONUS:
2098. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DEF_GRADE_BONUS,
2099. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
2100. break;
2101. }
2102. }
2104. if (GetDungeon())
2105. GetDungeon()->UsePotion(this);
2107. if (GetWarMap())
2108. GetWarMap()->UsePotion(this, item);
2110. item->SetCount(item->GetCount() - 1);
2111. break;
2113. default:
2114. {
2115. if (item->GetSubType() == USE_SPECIAL)
2116. {
2117. sys_log(0, "ITEM_UNIQUE: USE_SPECIAL %u", item->GetVnum());
2119. switch (item->GetVnum())
2120. {
2121. case 71049: // 비단보따리
2122. if (LC_IsYMIR() == true || LC_IsKorea() == true)
2123. {
2124. if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
2125. {
2126. UseSilkBotary();
2127. }
2128. else
2129. {
2130. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인 상점을 열 수 없는 지역입니다"));
2131. }
2132. }
2133. else
2134. {
2135. UseSilkBotary();
2136. }
2137. break;
2138. }
2139. }
2140. else
2141. {
2142. if (!item->IsEquipped())
2143. EquipItem(item);
2144. else
2145. UnequipItem(item);
2146. }
2147. }
2148. break;
2149. }
2150. }
2151. break;
2153. case ITEM_COSTUME:
2154. case ITEM_WEAPON:
2155. case ITEM_ARMOR:
2156. case ITEM_ROD:
2157. case ITEM_RING: // 신규 반지 아이템
2158. case ITEM_BELT: // 신규 벨트 아이템
2159. // MINING
2160. case ITEM_PICK:
2161. // END_OF_MINING
2162. if (!item->IsEquipped())
2163. EquipItem(item);
2164. else
2165. UnequipItem(item);
2166. break;
2167. // 착용하지 않은 용혼석은 사용할 수 없다.
2168. // 정상적인 클라라면, 용혼석에 관하여 item use 패킷을 보낼 수 없다.
2169. // 용혼석 착용은 item move 패킷으로 한다.
2170. // 착용한 용혼석은 추출한다.
2171. case ITEM_DS:
2172. {
2173. if (!item->IsEquipped())
2174. return false;
2175. return DSManager::instance().PullOut(this, NPOS, item);
2176. break;
2177. }
2178. case ITEM_SPECIAL_DS:
2179. if (!item->IsEquipped())
2180. EquipItem(item);
2181. else
2182. UnequipItem(item);
2183. break;
2185. case ITEM_FISH:
2186. {
2187. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
2188. {
2189. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
2190. return false;
2191. }
2193. if (item->GetSubType() == FISH_ALIVE)
2194. fishing::UseFish(this, item);
2195. }
2196. break;
2198. case ITEM_TREASURE_BOX:
2199. {
2200. return false;
2201. //ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠로 잠겨 있어서 열리지 않는것 같다. 열쇠를 구해보자."));
2202. }
2203. break;
2205. case ITEM_TREASURE_KEY:
2206. {
2207. LPITEM item2;
2209. if (!GetItem(DestCell) || !(item2 = GetItem(DestCell)))
2210. return false;
2212. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
2213. return false;
2215. if (item2->GetType() != ITEM_TREASURE_BOX)
2216. {
2217. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠로 여는 물건이 아닌것 같다."));
2218. return false;
2219. }
2221. if (item->GetValue(0) == item2->GetValue(0))
2222. {
2223. //ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠는 맞으나 아이템 주는 부분 구현이 안되었습니다."));
2224. DWORD dwBoxVnum = item2->GetVnum();
2225. std::vector <DWORD> dwVnums;
2226. std::vector <DWORD> dwCounts;
2227. std::vector <LPITEM> item_gets(0);
2228. int count = 0;
2230. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
2231. {
2232. ITEM_MANAGER::instance().RemoveItem(item);
2233. ITEM_MANAGER::instance().RemoveItem(item2);
2235. for (int i = 0; i < count; i++){
2236. switch (dwVnums[i])
2237. {
2238. case CSpecialItemGroup::GOLD:
2239. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
2240. break;
2241. case CSpecialItemGroup::EXP:
2242. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
2243. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
2244. break;
2245. case CSpecialItemGroup::MOB:
2246. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
2247. break;
2248. case CSpecialItemGroup::SLOW:
2249. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
2250. break;
2251. case CSpecialItemGroup::DRAIN_HP:
2252. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
2253. break;
2254. case CSpecialItemGroup::POISON:
2255. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
2256. break;
2257. case CSpecialItemGroup::MOB_GROUP:
2258. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
2259. break;
2260. default:
2261. if (item_gets[i])
2262. {
2263. if (dwCounts[i] > 1)
2264. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
2265. else
2266. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
2268. }
2269. }
2270. }
2271. }
2272. else
2273. {
2274. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠가 맞지 않는 것 같다."));
2275. return false;
2276. }
2277. }
2278. else
2279. {
2280. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠가 맞지 않는 것 같다."));
2281. return false;
2282. }
2283. }
2284. break;
2286. case ITEM_GIFTBOX:
2287. {
2288. DWORD dwBoxVnum = item->GetVnum();
2289. std::vector <DWORD> dwVnums;
2290. std::vector <DWORD> dwCounts;
2291. std::vector <LPITEM> item_gets(NULL);
2292. int count = 0;
2294. if (dwBoxVnum == 50033 && LC_IsYMIR()) // 알수없는 상자
2295. {
2296. if (GetLevel() < 15)
2297. {
2298. ChatPacket(CHAT_TYPE_INFO, "15레벨 이하에서는 사용할 수 없습니다.");
2299. return false;
2300. }
2301. }
2303. if( (dwBoxVnum > 51500 && dwBoxVnum < 52000) || (dwBoxVnum >= 50255 && dwBoxVnum <= 50260) ) // 용혼원석들
2304. {
2305. if( !(this->DragonSoul_IsQualified()) )
2306. {
2307. ChatPacket(CHAT_TYPE_INFO,LC_TEXT("먼저 용혼석 퀘스트를 완료하셔야 합니다."));
2308. return false;
2309. }
2310. }
2312. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
2313. {
2314. item->SetCount(item->GetCount()-1);
2316. for (int i = 0; i < count; i++){
2317. switch (dwVnums[i])
2318. {
2319. case CSpecialItemGroup::GOLD:
2320. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
2321. break;
2322. case CSpecialItemGroup::EXP:
2323. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
2324. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
2325. break;
2326. case CSpecialItemGroup::MOB:
2327. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
2328. break;
2329. case CSpecialItemGroup::SLOW:
2330. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
2331. break;
2332. case CSpecialItemGroup::DRAIN_HP:
2333. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
2334. break;
2335. case CSpecialItemGroup::POISON:
2336. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
2337. break;
2338. case CSpecialItemGroup::MOB_GROUP:
2339. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
2340. break;
2341. default:
2342. if (item_gets[i])
2343. {
2344. if (dwCounts[i] > 1)
2345. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
2346. else
2347. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
2348. }
2349. }
2350. }
2351. }
2352. else
2353. {
2354. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
2355. return false;
2356. }
2357. }
2358. break;
2360. case ITEM_SKILLFORGET:
2361. {
2362. if (!item->GetSocket(0))
2363. {
2364. item->SetCount(item->GetCount() - 1);
2365. return false;
2366. }
2368. DWORD dwVnum = item->GetSocket(0);
2370. if (SkillLevelDown(dwVnum))
2371. {
2372. item->SetCount(item->GetCount() - 1);
2373. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("스킬 레벨을 내리는데 성공하였습니다."));
2374. }
2375. else
2376. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("스킬 레벨을 내릴 수 없습니다."));
2377. }
2378. break;
2380. case ITEM_SKILLBOOK:
2381. {
2382. if (IsPolymorphed())
2383. {
2384. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
2385. return false;
2386. }
2388. DWORD dwVnum = 0;
2390. if (item->GetVnum() == 50300)
2391. {
2392. dwVnum = item->GetSocket(0);
2393. }
2394. else
2395. {
2396. // 새로운 수련서는 value 0 에 스킬 번호가 있으므로 그것을 사용.
2397. dwVnum = item->GetValue(0);
2398. }
2400. if (0 == dwVnum)
2401. {
2402. item->SetCount(item->GetCount() - 1);
2404. return false;
2405. }
2407. if (true == LearnSkillByBook(dwVnum))
2408. {
2409. item->SetCount(item->GetCount() - 1);
2411. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
2413. if (distribution_test_server)
2414. iReadDelay /= 3;
2416. //한국 본섭의 경우에는 시간을 24시간 고정
2417. if (LC_IsKorea())
2418. iReadDelay = 86400;
2420. SetSkillNextReadTime(dwVnum, get_global_time() + iReadDelay);
2421. }
2422. }
2423. break;
2425. case ITEM_USE:
2426. {
2427. if (item->GetVnum() > 50800 && item->GetVnum() <= 50820)
2428. {
2429. if (test_server)
2430. sys_log (0, "ADD addtional effect : vnum(%d) subtype(%d)", item->GetOriginalVnum(), item->GetSubType());
2432. int affect_type = AFFECT_EXP_BONUS_EURO_FREE;
2433. int apply_type = aApplyInfo[item->GetValue(0)].bPointType;
2434. int apply_value = item->GetValue(2);
2435. int apply_duration = item->GetValue(1);
2437. switch (item->GetSubType())
2438. {
2439. case USE_ABILITY_UP:
2440. if (FindAffect(affect_type, apply_type))
2441. {
2442. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
2443. return false;
2444. }
2446. {
2447. switch (item->GetValue(0))
2448. {
2449. case APPLY_MOV_SPEED:
2450. AddAffect(affect_type, apply_type, apply_value, AFF_MOV_SPEED_POTION, apply_duration, 0, true, true);
2451. break;
2453. case APPLY_ATT_SPEED:
2454. AddAffect(affect_type, apply_type, apply_value, AFF_ATT_SPEED_POTION, apply_duration, 0, true, true);
2455. break;
2457. case APPLY_STR:
2458. case APPLY_DEX:
2459. case APPLY_CON:
2460. case APPLY_INT:
2461. case APPLY_CAST_SPEED:
2462. case APPLY_RESIST_MAGIC:
2463. case APPLY_ATT_GRADE_BONUS:
2464. case APPLY_DEF_GRADE_BONUS:
2465. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, true, true);
2466. break;
2467. }
2468. }
2470. if (GetDungeon())
2471. GetDungeon()->UsePotion(this);
2473. if (GetWarMap())
2474. GetWarMap()->UsePotion(this, item);
2476. item->SetCount(item->GetCount() - 1);
2477. break;
2479. case USE_AFFECT :
2480. {
2481. #ifdef ENABLE_YMIR_AFFECT_FIX
2482. if ((CheckTimeUsed(item) == false)) { return false; }
2483. #endif
2484. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType))
2485. {
2486. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
2487. }
2488. else
2489. {
2490. // PC_BANG_ITEM_ADD
2491. if (item->IsPCBangItem() == true)
2492. {
2493. // PC방인지 체크해서 처리
2494. if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
2495. {
2496. // PC방이 아님!
2497. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 PC방에서만 사용할 수 있습니다."));
2498. return false;
2499. }
2500. }
2501. // END_PC_BANG_ITEM_ADD
2503. AddAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false, true);
2504. item->SetCount(item->GetCount() - 1);
2505. }
2506. }
2507. break;
2509. case USE_POTION_NODELAY:
2510. {
2511. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
2512. {
2513. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
2514. {
2515. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
2516. return false;
2517. }
2519. switch (item->GetVnum())
2520. {
2521. case 70020 :
2522. case 71018 :
2523. case 71019 :
2524. case 71020 :
2525. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
2526. {
2527. if (m_nPotionLimit <= 0)
2528. {
2529. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
2530. return false;
2531. }
2532. }
2533. break;
2535. default :
2536. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
2537. return false;
2538. break;
2539. }
2540. }
2542. bool used = false;
2544. if (item->GetValue(0) != 0) // HP 절대값 회복
2545. {
2546. if (GetHP() < GetMaxHP())
2547. {
2548. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
2549. EffectPacket(SE_HPUP_RED);
2550. used = TRUE;
2551. }
2552. }
2554. if (item->GetValue(1) != 0) // SP 절대값 회복
2555. {
2556. if (GetSP() < GetMaxSP())
2557. {
2558. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
2559. EffectPacket(SE_SPUP_BLUE);
2560. used = TRUE;
2561. }
2562. }
2564. if (item->GetValue(3) != 0) // HP % 회복
2565. {
2566. if (GetHP() < GetMaxHP())
2567. {
2568. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
2569. EffectPacket(SE_HPUP_RED);
2570. used = TRUE;
2571. }
2572. }
2574. if (item->GetValue(4) != 0) // SP % 회복
2575. {
2576. if (GetSP() < GetMaxSP())
2577. {
2578. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
2579. EffectPacket(SE_SPUP_BLUE);
2580. used = TRUE;
2581. }
2582. }
2584. if (used)
2585. {
2586. if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
2587. {
2588. if (test_server)
2589. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("월병 또는 종자 를 사용하였습니다"));
2590. SetUseSeedOrMoonBottleTime();
2591. }
2592. if (GetDungeon())
2593. GetDungeon()->UsePotion(this);
2595. if (GetWarMap())
2596. GetWarMap()->UsePotion(this, item);
2598. m_nPotionLimit--;
2600. //RESTRICT_USE_SEED_OR_MOONBOTTLE
2601. item->SetCount(item->GetCount() - 1);
2602. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
2603. }
2604. }
2605. break;
2606. }
2608. return true;
2609. }
2612. if (item->GetVnum() >= 27863 && item->GetVnum() <= 27883)
2613. {
2614. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
2615. {
2616. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
2617. return false;
2618. }
2619. }
2621. if (test_server)
2622. {
2623. //sys_log (0, "USE_ITEM %s Type %d SubType %d vnum %d", item->GetName(), item->GetType(), item->GetSubType(), item->GetOriginalVnum());
2624. }
2626. switch (item->GetSubType())
2627. {
2628. case USE_TIME_CHARGE_PER:
2629. {
2630. LPITEM pDestItem = GetItem(DestCell);
2631. if (NULL == pDestItem)
2632. {
2633. return false;
2634. }
2635. // 우선 용혼석에 관해서만 하도록 한다.
2636. if (pDestItem->IsDragonSoul())
2637. {
2638. int ret;
2639. char buf[128];
2640. if (item->GetVnum() == DRAGON_HEART_VNUM)
2641. {
2642. ret = pDestItem->GiveMoreTime_Per((float)item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
2643. }
2644. else
2645. {
2646. ret = pDestItem->GiveMoreTime_Per((float)item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
2647. }
2648. if (ret > 0)
2649. {
2650. if (item->GetVnum() == DRAGON_HEART_VNUM)
2651. {
2652. sprintf(buf, "Inc %ds by item{VN:%d SOC%d:%d}", ret, item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
2653. }
2654. else
2655. {
2656. sprintf(buf, "Inc %ds by item{VN:%d VAL%d:%d}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
2657. }
2659. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d초 만큼 충전되었습니다."), ret);
2660. item->SetCount(item->GetCount() - 1);
2661. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
2662. return true;
2663. }
2664. else
2665. {
2666. if (item->GetVnum() == DRAGON_HEART_VNUM)
2667. {
2668. sprintf(buf, "No change by item{VN:%d SOC%d:%d}", item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
2669. }
2670. else
2671. {
2672. sprintf(buf, "No change by item{VN:%d VAL%d:%d}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
2673. }
2675. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("충전할 수 없습니다."));
2676. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
2677. return false;
2678. }
2679. }
2680. else
2681. return false;
2682. }
2683. break;
2684. case USE_TIME_CHARGE_FIX:
2685. {
2686. LPITEM pDestItem = GetItem(DestCell);
2687. if (NULL == pDestItem)
2688. {
2689. return false;
2690. }
2691. // 우선 용혼석에 관해서만 하도록 한다.
2692. if (pDestItem->IsDragonSoul())
2693. {
2694. int ret = pDestItem->GiveMoreTime_Fix(item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
2695. char buf[128];
2696. if (ret)
2697. {
2698. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d초 만큼 충전되었습니다."), ret);
2699. sprintf(buf, "Increase %ds by item{VN:%d VAL%d:%d}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
2700. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
2701. item->SetCount(item->GetCount() - 1);
2702. return true;
2703. }
2704. else
2705. {
2706. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("충전할 수 없습니다."));
2707. sprintf(buf, "No change by item{VN:%d VAL%d:%d}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
2708. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
2709. return false;
2710. }
2711. }
2712. else
2713. return false;
2714. }
2715. break;
2716. case USE_SPECIAL:
2718. switch (item->GetVnum())
2719. {
2720. //크리스마스 란주
2721. case ITEM_NOG_POCKET:
2722. {
2723. /*
2724. 란주능력치 : item_proto value 의미
2725. 이동속도 value 1
2726. 공격력 value 2
2727. 경험치 value 3
2728. 지속시간 value 0 (단위 초)
2730. */
2731. if (FindAffect(AFFECT_NOG_ABILITY))
2732. {
2733. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
2734. return false;
2735. }
2736. long time = item->GetValue(0);
2737. long moveSpeedPer = item->GetValue(1);
2738. long attPer = item->GetValue(2);
2739. long expPer = item->GetValue(3);
2740. AddAffect(AFFECT_NOG_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
2741. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
2742. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
2743. item->SetCount(item->GetCount() - 1);
2744. }
2745. break;
2747. //라마단용 사탕
2748. case ITEM_RAMADAN_CANDY:
2749. {
2750. /*
2751. 사탕능력치 : item_proto value 의미
2752. 이동속도 value 1
2753. 공격력 value 2
2754. 경험치 value 3
2755. 지속시간 value 0 (단위 초)
2757. */
2758. long time = item->GetValue(0);
2759. long moveSpeedPer = item->GetValue(1);
2760. long attPer = item->GetValue(2);
2761. long expPer = item->GetValue(3);
2762. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
2763. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
2764. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
2765. item->SetCount(item->GetCount() - 1);
2766. }
2767. break;
2768. case ITEM_MARRIAGE_RING:
2769. {
2770. marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
2771. if (pMarriage)
2772. {
2773. if (pMarriage->ch1 != NULL)
2774. {
2775. if (CArenaManager::instance().IsArenaMap(pMarriage->ch1->GetMapIndex()) == true)
2776. {
2777. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
2778. break;
2779. }
2780. }
2782. if (pMarriage->ch2 != NULL)
2783. {
2784. if (CArenaManager::instance().IsArenaMap(pMarriage->ch2->GetMapIndex()) == true)
2785. {
2786. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
2787. break;
2788. }
2789. }
2791. int consumeSP = CalculateConsumeSP(this);
2793. if (consumeSP < 0)
2794. return false;
2796. PointChange(POINT_SP, -consumeSP, false);
2798. WarpToPID(pMarriage->GetOther(GetPlayerID()));
2799. }
2800. else
2801. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("결혼 상태가 아니면 결혼반지를 사용할 수 없습니다."));
2802. }
2803. break;
2805. //기존 용기의 망토
2806. case UNIQUE_ITEM_CAPE_OF_COURAGE:
2807. //라마단 보상용 용기의 망토
2808. case 79505:
2809. {
2810. if (IsDead() || GetExchange() || GetMyShop() || GetOfflineShop() || GetShopOwner() || IsOpenSafebox() || GetShop())
2811. {
2812. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("UYARI"));
2813. return false;
2814. }
2816. if (item->GetCount() > 23 )
2817. {
2818. int pos = GetEmptyInventory(item->GetSize());
2819. if (-1 == pos)
2820. {
2821. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BOSYERYOK"));
2822. break;
2823. }
2825. item->SetCount(item->GetCount()-24);
2826. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(79506,1);
2827. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
2828. }
2829. else
2830. {
2831. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("YETERLIKARTYOK"));
2832. return false;
2833. }
2834. }
2835. break;
2836. case 70057:
2837. case REWARD_BOX_UNIQUE_ITEM_CAPE_OF_COURAGE:
2838. AggregateMonster();
2839. item->SetCount(item->GetCount()-1);
2840. break;
2842. case UNIQUE_ITEM_WHITE_FLAG:
2843. ForgetMyAttacker();
2844. item->SetCount(item->GetCount()-1);
2845. break;
2847. case UNIQUE_ITEM_TREASURE_BOX:
2848. break;
2850. case 30093:
2851. case 30094:
2852. case 30095:
2853. case 30096:
2854. // 복주머니
2855. {
2856. const int MAX_BAG_INFO = 26;
2857. static struct LuckyBagInfo
2858. {
2859. DWORD count;
2860. int prob;
2861. DWORD vnum;
2862. } b1[MAX_BAG_INFO] =
2863. {
2864. { 1000, 302, 1 },
2865. { 10, 150, 27002 },
2866. { 10, 75, 27003 },
2867. { 10, 100, 27005 },
2868. { 10, 50, 27006 },
2869. { 10, 80, 27001 },
2870. { 10, 50, 27002 },
2871. { 10, 80, 27004 },
2872. { 10, 50, 27005 },
2873. { 1, 10, 50300 },
2874. { 1, 6, 92 },
2875. { 1, 2, 132 },
2876. { 1, 6, 1052 },
2877. { 1, 2, 1092 },
2878. { 1, 6, 2082 },
2879. { 1, 2, 2122 },
2880. { 1, 6, 3082 },
2881. { 1, 2, 3122 },
2882. { 1, 6, 5052 },
2883. { 1, 2, 5082 },
2884. { 1, 6, 7082 },
2885. { 1, 2, 7122 },
2886. { 1, 1, 11282 },
2887. { 1, 1, 11482 },
2888. { 1, 1, 11682 },
2889. { 1, 1, 11882 },
2890. };
2892. struct LuckyBagInfo b2[MAX_BAG_INFO] =
2893. {
2894. { 1000, 302, 1 },
2895. { 10, 150, 27002 },
2896. { 10, 75, 27002 },
2897. { 10, 100, 27005 },
2898. { 10, 50, 27005 },
2899. { 10, 80, 27001 },
2900. { 10, 50, 27002 },
2901. { 10, 80, 27004 },
2902. { 10, 50, 27005 },
2903. { 1, 10, 50300 },
2904. { 1, 6, 92 },
2905. { 1, 2, 132 },
2906. { 1, 6, 1052 },
2907. { 1, 2, 1092 },
2908. { 1, 6, 2082 },
2909. { 1, 2, 2122 },
2910. { 1, 6, 3082 },
2911. { 1, 2, 3122 },
2912. { 1, 6, 5052 },
2913. { 1, 2, 5082 },
2914. { 1, 6, 7082 },
2915. { 1, 2, 7122 },
2916. { 1, 1, 11282 },
2917. { 1, 1, 11482 },
2918. { 1, 1, 11682 },
2919. { 1, 1, 11882 },
2920. };
2922. LuckyBagInfo * bi = NULL;
2923. if (LC_IsHongKong())
2924. bi = b2;
2925. else
2926. bi = b1;
2928. int pct = number(1, 1000);
2930. int i;
2931. for (i=0;i<MAX_BAG_INFO;i++)
2932. {
2933. if (pct <= bi[i].prob)
2934. break;
2935. pct -= bi[i].prob;
2936. }
2937. if (i>=MAX_BAG_INFO)
2938. return false;
2940. if (bi[i].vnum == 50300)
2941. {
2942. // 스킬수련서는 특수하게 준다.
2943. GiveRandomSkillBook();
2944. }
2945. else if (bi[i].vnum == 1)
2946. {
2947. PointChange(POINT_GOLD, 1000, true);
2948. }
2949. else
2950. {
2951. AutoGiveItem(bi[i].vnum, bi[i].count);
2952. }
2953. item->SetCount(item->GetCount() - 1);
2954. }
2955. break;
2957. case 50004: // 이벤트용 감지기
2958. {
2959. if (item->GetSocket(0))
2960. {
2961. item->SetSocket(0, item->GetSocket(0) + 1);
2962. }
2963. else
2964. {
2965. // 처음 사용시
2966. int iMapIndex = GetMapIndex();
2968. PIXEL_POSITION pos;
2970. if (SECTREE_MANAGER::instance().GetRandomLocation(iMapIndex, pos, 700))
2971. {
2972. item->SetSocket(0, 1);
2973. item->SetSocket(1, pos.x);
2974. item->SetSocket(2, pos.y);
2975. }
2976. else
2977. {
2978. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 곳에선 이벤트용 감지기가 동작하지 않는것 같습니다."));
2979. return false;
2980. }
2981. }
2983. int dist = 0;
2984. float distance = (DISTANCE_SQRT(GetX()-item->GetSocket(1), GetY()-item->GetSocket(2)));
2986. if (distance < 1000.0f)
2987. {
2988. // 발견!
2989. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이벤트용 감지기가 신비로운 빛을 내며 사라집니다."));
2991. // 사용횟수에 따라 주는 아이템을 다르게 한다.
2992. struct TEventStoneInfo
2993. {
2994. DWORD dwVnum;
2995. int count;
2996. int prob;
2997. };
2998. const int EVENT_STONE_MAX_INFO = 15;
2999. TEventStoneInfo info_10[EVENT_STONE_MAX_INFO] =
3000. {
3001. { 27001, 10, 8 },
3002. { 27004, 10, 6 },
3003. { 27002, 10, 12 },
3004. { 27005, 10, 12 },
3005. { 27100, 1, 9 },
3006. { 27103, 1, 9 },
3007. { 27101, 1, 10 },
3008. { 27104, 1, 10 },
3009. { 27999, 1, 12 },
3011. { 25040, 1, 4 },
3013. { 27410, 1, 0 },
3014. { 27600, 1, 0 },
3015. { 25100, 1, 0 },
3017. { 50001, 1, 0 },
3018. { 50003, 1, 1 },
3019. };
3020. TEventStoneInfo info_7[EVENT_STONE_MAX_INFO] =
3021. {
3022. { 27001, 10, 1 },
3023. { 27004, 10, 1 },
3024. { 27004, 10, 9 },
3025. { 27005, 10, 9 },
3026. { 27100, 1, 5 },
3027. { 27103, 1, 5 },
3028. { 27101, 1, 10 },
3029. { 27104, 1, 10 },
3030. { 27999, 1, 14 },
3032. { 25040, 1, 5 },
3034. { 27410, 1, 5 },
3035. { 27600, 1, 5 },
3036. { 25100, 1, 5 },
3038. { 50001, 1, 0 },
3039. { 50003, 1, 5 },
3041. };
3042. TEventStoneInfo info_4[EVENT_STONE_MAX_INFO] =
3043. {
3044. { 27001, 10, 0 },
3045. { 27004, 10, 0 },
3046. { 27002, 10, 0 },
3047. { 27005, 10, 0 },
3048. { 27100, 1, 0 },
3049. { 27103, 1, 0 },
3050. { 27101, 1, 0 },
3051. { 27104, 1, 0 },
3052. { 27999, 1, 25 },
3054. { 25040, 1, 0 },
3056. { 27410, 1, 0 },
3057. { 27600, 1, 0 },
3058. { 25100, 1, 15 },
3060. { 50001, 1, 10 },
3061. { 50003, 1, 50 },
3063. };
3065. {
3066. TEventStoneInfo* info;
3067. if (item->GetSocket(0) <= 4)
3068. info = info_4;
3069. else if (item->GetSocket(0) <= 7)
3070. info = info_7;
3071. else
3072. info = info_10;
3074. int prob = number(1, 100);
3076. for (int i = 0; i < EVENT_STONE_MAX_INFO; ++i)
3077. {
3078. if (!info[i].prob)
3079. continue;
3081. if (prob <= info[i].prob)
3082. {
3083. if (info[i].dwVnum == 50001)
3084. {
3085. DWORD * pdw = M2_NEW DWORD[2];
3087. pdw[0] = info[i].dwVnum;
3088. pdw[1] = info[i].count;
3090. // 추첨서는 소켓을 설정한다
3091. DBManager::instance().ReturnQuery(QID_LOTTO, GetPlayerID(), pdw,
3092. "INSERT INTO lotto_list VALUES(0, 'server%s', %u, NOW())",
3093. get_table_postfix(), GetPlayerID());
3094. }
3095. else
3096. AutoGiveItem(info[i].dwVnum, info[i].count);
3098. break;
3099. }
3100. prob -= info[i].prob;
3101. }
3102. }
3104. char chatbuf[CHAT_MAX_LEN + 1];
3105. int len = snprintf(chatbuf, sizeof(chatbuf), "StoneDetect %u 0 0", (DWORD)GetVID());
3107. if (len < 0 || len >= (int) sizeof(chatbuf))
3108. len = sizeof(chatbuf) - 1;
3110. ++len; // \0 문자까지 보내기
3112. TPacketGCChat pack_chat;
3113. pack_chat.header = HEADER_GC_CHAT;
3114. pack_chat.size = sizeof(TPacketGCChat) + len;
3115. pack_chat.type = CHAT_TYPE_COMMAND;
3116. pack_chat.id = 0;
3117. pack_chat.bEmpire = GetDesc()->GetEmpire();
3118. //pack_chat.id = vid;
3120. TEMP_BUFFER buf;
3121. buf.write(&pack_chat, sizeof(TPacketGCChat));
3122. buf.write(chatbuf, len);
3124. PacketAround(buf.read_peek(), buf.size());
3126. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 1");
3127. return true;
3128. }
3129. else if (distance < 20000)
3130. dist = 1;
3131. else if (distance < 70000)
3132. dist = 2;
3133. else
3134. dist = 3;
3136. // 많이 사용했으면 사라진다.
3137. const int STONE_DETECT_MAX_TRY = 10;
3138. if (item->GetSocket(0) >= STONE_DETECT_MAX_TRY)
3139. {
3140. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이벤트용 감지기가 흔적도 없이 사라집니다."));
3141. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 0");
3142. AutoGiveItem(27002);
3143. return true;
3144. }
3146. if (dist)
3147. {
3148. char chatbuf[CHAT_MAX_LEN + 1];
3149. int len = snprintf(chatbuf, sizeof(chatbuf),
3150. "StoneDetect %u %d %d",
3151. (DWORD)GetVID(), dist, (int)GetDegreeFromPositionXY(GetX(), item->GetSocket(2), item->GetSocket(1), GetY()));
3153. if (len < 0 || len >= (int) sizeof(chatbuf))
3154. len = sizeof(chatbuf) - 1;
3156. ++len; // \0 문자까지 보내기
3158. TPacketGCChat pack_chat;
3159. pack_chat.header = HEADER_GC_CHAT;
3160. pack_chat.size = sizeof(TPacketGCChat) + len;
3161. pack_chat.type = CHAT_TYPE_COMMAND;
3162. pack_chat.id = 0;
3163. pack_chat.bEmpire = GetDesc()->GetEmpire();
3164. //pack_chat.id = vid;
3166. TEMP_BUFFER buf;
3167. buf.write(&pack_chat, sizeof(TPacketGCChat));
3168. buf.write(chatbuf, len);
3170. PacketAround(buf.read_peek(), buf.size());
3171. }
3173. }
3174. break;
3176. case 27989: // 영석감지기
3177. case 76006: // 선물용 영석감지기
3178. {
3179. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(GetMapIndex());
3181. if (pMap != NULL)
3182. {
3183. item->SetSocket(0, item->GetSocket(0) + 1);
3185. FFindStone f;
3187. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
3188. pMap->for_each(f);
3190. if (f.m_mapStone.size() > 0)
3191. {
3192. std::map<DWORD, LPCHARACTER>::iterator stone = f.m_mapStone.begin();
3194. DWORD max = UINT_MAX;
3195. LPCHARACTER pTarget = stone->second;
3197. while (stone != f.m_mapStone.end())
3198. {
3199. DWORD dist = (DWORD)DISTANCE_SQRT(GetX()-stone->second->GetX(), GetY()-stone->second->GetY());
3201. if (dist != 0 && max > dist)
3202. {
3203. max = dist;
3204. pTarget = stone->second;
3205. }
3206. stone++;
3207. }
3209. if (pTarget != NULL)
3210. {
3211. int val = 3;
3213. if (max < 10000) val = 2;
3214. else if (max < 70000) val = 1;
3216. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u %d %d", (DWORD)GetVID(), val,
3217. (int)GetDegreeFromPositionXY(GetX(), pTarget->GetY(), pTarget->GetX(), GetY()));
3218. }
3219. else
3220. {
3221. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("감지기를 작용하였으나 감지되는 영석이 없습니다."));
3222. }
3223. }
3224. else
3225. {
3226. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("감지기를 작용하였으나 감지되는 영석이 없습니다."));
3227. }
3229. if (item->GetSocket(0) >= 6)
3230. {
3231. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u 0 0", (DWORD)GetVID());
3232. item->SetCount(item->GetCount() - 1);
3233. }
3234. }
3235. break;
3236. }
3237. break;
3239. case 27996: // 독병
3240. item->SetCount(item->GetCount() - 1);
3241. /*if (GetSkillLevel(SKILL_CREATE_POISON))
3242. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE, 3, AFF_DRINK_POISON, 15*60, 0, true);
3243. else
3244. {
3245. // 독다루기가 없으면 50% 즉사 50% 공격력 +2
3246. if (number(0, 1))
3247. {
3248. if (GetHP() > 100)
3249. PointChange(POINT_HP, -(GetHP() - 1));
3250. else
3251. Dead();
3252. }
3253. else
3254. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE, 2, AFF_DRINK_POISON, 15*60, 0, true);
3255. }*/
3256. break;
3258. case 27987: // 조개
3259. // 50 돌조각 47990
3260. // 30 꽝
3261. // 10 백진주 47992
3262. // 7 청진주 47993
3263. // 3 피진주 47994
3264. {
3265. item->SetCount(item->GetCount() - 1);
3267. int r = number(1, 100);
3269. if (r <= 50)
3270. {
3271. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 돌조각이 나왔습니다."));
3272. AutoGiveItem(27990);
3273. }
3274. else
3275. {
3276. const int prob_table_euckr[] =
3277. {
3278. 80, 90, 97
3279. };
3281. const int prob_table_gb2312[] =
3282. {
3283. 95, 97, 99
3284. };
3286. const int * prob_table = !g_iUseLocale ? prob_table_euckr : prob_table_gb2312;
3288. if (r <= prob_table[0])
3289. {
3290. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개가 흔적도 없이 사라집니다."));
3291. }
3292. else if (r <= prob_table[1])
3293. {
3294. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 백진주가 나왔습니다."));
3295. AutoGiveItem(27992);
3296. }
3297. else if (r <= prob_table[2])
3298. {
3299. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 청진주가 나왔습니다."));
3300. AutoGiveItem(27993);
3301. }
3302. else
3303. {
3304. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 피진주가 나왔습니다."));
3305. AutoGiveItem(27994);
3306. }
3307. }
3308. }
3309. break;
3311. case 71013: // 축제용폭죽
3312. CreateFly(number(FLY_FIREWORK1, FLY_FIREWORK6), this);
3313. item->SetCount(item->GetCount() - 1);
3314. break;
3316. case 50100: // 폭죽
3317. case 50101:
3318. case 50102:
3319. case 50103:
3320. case 50104:
3321. case 50105:
3322. case 50106:
3323. CreateFly(item->GetVnum() - 50100 + FLY_FIREWORK1, this);
3324. item->SetCount(item->GetCount() - 1);
3325. break;
3327. case 50200: // 보따리
3328. if (LC_IsYMIR() == true || LC_IsKorea() == true)
3329. {
3330. if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
3331. {
3332. __OpenPrivateShop();
3333. }
3334. else
3335. {
3336. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인 상점을 열 수 없는 지역입니다"));
3337. }
3338. }
3339. else
3340. {
3341. __OpenPrivateShop();
3342. }
3343. break;
3345. case fishing::FISH_MIND_PILL_VNUM:
3346. AddAffect(AFFECT_FISH_MIND_PILL, POINT_NONE, 0, AFF_FISH_MIND, 20*60, 0, true);
3347. item->SetCount(item->GetCount() - 1);
3348. break;
3350. case 50301: // 통솔력 수련서
3351. case 50302:
3352. case 50303:
3353. {
3354. if (IsPolymorphed() == true)
3355. {
3356. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 능력을 올릴 수 없습니다."));
3357. return false;
3358. }
3360. int lv = GetSkillLevel(SKILL_LEADERSHIP);
3362. if (lv < item->GetValue(0))
3363. {
3364. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 너무 어려워 이해하기가 힘듭니다."));
3365. return false;
3366. }
3368. if (lv >= item->GetValue(1))
3369. {
3370. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 아무리 봐도 도움이 될 것 같지 않습니다."));
3371. return false;
3372. }
3374. if (LearnSkillByBook(SKILL_LEADERSHIP))
3375. {
3376. item->SetCount(item->GetCount() - 1);
3378. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3379. if (distribution_test_server) iReadDelay /= 3;
3381. SetSkillNextReadTime(SKILL_LEADERSHIP, get_global_time() + iReadDelay);
3382. }
3383. }
3384. break;
3386. case 50304: // 연계기 수련서
3387. case 50305:
3388. case 50306:
3389. {
3390. if (IsPolymorphed())
3391. {
3392. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
3393. return false;
3395. }
3396. if (GetSkillLevel(SKILL_COMBO) == 0 && GetLevel() < 30)
3397. {
3398. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨 30이 되기 전에는 습득할 수 있을 것 같지 않습니다."));
3399. return false;
3400. }
3402. if (GetSkillLevel(SKILL_COMBO) == 1 && GetLevel() < 50)
3403. {
3404. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨 50이 되기 전에는 습득할 수 있을 것 같지 않습니다."));
3405. return false;
3406. }
3408. if (GetSkillLevel(SKILL_COMBO) >= 2)
3409. {
3410. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("연계기는 더이상 수련할 수 없습니다."));
3411. return false;
3412. }
3414. int iPct = item->GetValue(0);
3416. if (LearnSkillByBook(SKILL_COMBO, iPct))
3417. {
3418. item->SetCount(item->GetCount() - 1);
3420. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3421. if (distribution_test_server) iReadDelay /= 3;
3423. SetSkillNextReadTime(SKILL_COMBO, get_global_time() + iReadDelay);
3424. }
3425. }
3426. break;
3427. case 50311: // 언어 수련서
3428. case 50312:
3429. case 50313:
3430. {
3431. if (IsPolymorphed())
3432. {
3433. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
3434. return false;
3436. }
3437. DWORD dwSkillVnum = item->GetValue(0);
3438. int iPct = MINMAX(0, item->GetValue(1), 100);
3439. if (GetSkillLevel(dwSkillVnum)>=20 || dwSkillVnum-SKILL_LANGUAGE1+1 == GetEmpire())
3440. {
3441. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 완벽하게 알아들을 수 있는 언어이다."));
3442. return false;
3443. }
3445. if (LearnSkillByBook(dwSkillVnum, iPct))
3446. {
3447. item->SetCount(item->GetCount() - 1);
3449. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3450. if (distribution_test_server) iReadDelay /= 3;
3452. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
3453. }
3454. }
3455. break;
3457. case 50061 : // 일본 말 소환 스킬 수련서
3458. {
3459. if (IsPolymorphed())
3460. {
3461. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
3462. return false;
3464. }
3465. DWORD dwSkillVnum = item->GetValue(0);
3466. int iPct = MINMAX(0, item->GetValue(1), 100);
3468. if (GetSkillLevel(dwSkillVnum) >= 10)
3469. {
3470. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
3471. return false;
3472. }
3474. if (LearnSkillByBook(dwSkillVnum, iPct))
3475. {
3476. item->SetCount(item->GetCount() - 1);
3478. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3479. if (distribution_test_server) iReadDelay /= 3;
3481. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
3482. }
3483. }
3484. break;
3486. case 50314: case 50315: case 50316: // 변신 수련서
3487. case 50323: case 50324: // 증혈 수련서
3488. case 50325: case 50326: // 철통 수련서
3489. {
3490. if (IsPolymorphed() == true)
3491. {
3492. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 능력을 올릴 수 없습니다."));
3493. return false;
3494. }
3496. int iSkillLevelLowLimit = item->GetValue(0);
3497. int iSkillLevelHighLimit = item->GetValue(1);
3498. int iPct = MINMAX(0, item->GetValue(2), 100);
3499. int iLevelLimit = item->GetValue(3);
3500. DWORD dwSkillVnum = 0;
3502. switch (item->GetVnum())
3503. {
3504. case 50314: case 50315: case 50316:
3505. dwSkillVnum = SKILL_POLYMORPH;
3506. break;
3508. case 50323: case 50324:
3509. dwSkillVnum = SKILL_ADD_HP;
3510. break;
3512. case 50325: case 50326:
3513. dwSkillVnum = SKILL_RESIST_PENETRATE;
3514. break;
3516. default:
3517. return false;
3518. }
3520. if (0 == dwSkillVnum)
3521. return false;
3523. if (GetLevel() < iLevelLimit)
3524. {
3525. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책을 읽으려면 레벨을 더 올려야 합니다."));
3526. return false;
3527. }
3529. if (GetSkillLevel(dwSkillVnum) >= 40)
3530. {
3531. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
3532. return false;
3533. }
3535. if (GetSkillLevel(dwSkillVnum) < iSkillLevelLowLimit)
3536. {
3537. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 너무 어려워 이해하기가 힘듭니다."));
3538. return false;
3539. }
3541. if (GetSkillLevel(dwSkillVnum) >= iSkillLevelHighLimit)
3542. {
3543. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책으로는 더 이상 수련할 수 없습니다."));
3544. return false;
3545. }
3547. if (LearnSkillByBook(dwSkillVnum, iPct))
3548. {
3549. item->SetCount(item->GetCount() - 1);
3551. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3552. if (distribution_test_server) iReadDelay /= 3;
3554. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
3555. }
3556. }
3557. break;
3559. case 50902:
3560. case 50903:
3561. case 50904:
3562. {
3563. if (IsPolymorphed())
3564. {
3565. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
3566. return false;
3568. }
3569. DWORD dwSkillVnum = SKILL_CREATE;
3570. int iPct = MINMAX(0, item->GetValue(1), 100);
3572. if (GetSkillLevel(dwSkillVnum)>=40)
3573. {
3574. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
3575. return false;
3576. }
3578. if (LearnSkillByBook(dwSkillVnum, iPct))
3579. {
3580. item->SetCount(item->GetCount() - 1);
3582. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3583. if (distribution_test_server) iReadDelay /= 3;
3585. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
3587. if (test_server)
3588. {
3589. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Success to learn skill ");
3590. }
3591. }
3592. else
3593. {
3594. if (test_server)
3595. {
3596. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Failed to learn skill ");
3597. }
3598. }
3599. }
3600. break;
3602. // MINING
3603. case ITEM_MINING_SKILL_TRAIN_BOOK:
3604. {
3605. if (IsPolymorphed())
3606. {
3607. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
3608. return false;
3610. }
3611. DWORD dwSkillVnum = SKILL_MINING;
3612. int iPct = MINMAX(0, item->GetValue(1), 100);
3614. if (GetSkillLevel(dwSkillVnum)>=40)
3615. {
3616. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
3617. return false;
3618. }
3620. if (LearnSkillByBook(dwSkillVnum, iPct))
3621. {
3622. item->SetCount(item->GetCount() - 1);
3624. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3625. if (distribution_test_server) iReadDelay /= 3;
3627. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
3628. }
3629. }
3630. break;
3631. // END_OF_MINING
3633. case ITEM_HORSE_SKILL_TRAIN_BOOK:
3634. {
3635. if (IsPolymorphed())
3636. {
3637. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
3638. return false;
3640. }
3641. DWORD dwSkillVnum = SKILL_HORSE;
3642. int iPct = MINMAX(0, item->GetValue(1), 100);
3644. if (GetLevel() < 50)
3645. {
3646. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 승마 스킬을 수련할 수 있는 레벨이 아닙니다."));
3647. return false;
3648. }
3650. if (!test_server && get_global_time() < GetSkillNextReadTime(dwSkillVnum))
3651. {
3652. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
3653. {
3654. // 주안술서 사용중에는 시간 제한 무시
3655. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
3656. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("주안술서를 통해 주화입마에서 빠져나왔습니다."));
3657. }
3658. else
3659. {
3660. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
3661. return false;
3662. }
3663. }
3665. if (GetPoint(POINT_HORSE_SKILL) >= 20 ||
3666. GetSkillLevel(SKILL_HORSE_WILDATTACK) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60 ||
3667. GetSkillLevel(SKILL_HORSE_WILDATTACK_RANGE) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60)
3668. {
3669. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 승마 수련서를 읽을 수 없습니다."));
3670. return false;
3671. }
3673. if (number(1, 100) <= iPct)
3674. {
3675. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("승마 수련서를 읽어 승마 스킬 포인트를 얻었습니다."));
3676. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("얻은 포인트로는 승마 스킬의 레벨을 올릴 수 있습니다."));
3677. PointChange(POINT_HORSE_SKILL, 1);
3679. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
3680. if (distribution_test_server) iReadDelay /= 3;
3682. if (!test_server)
3683. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
3684. }
3685. else
3686. {
3687. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("승마 수련서 이해에 실패하였습니다."));
3688. }
3690. item->SetCount(item->GetCount() - 1);
3691. }
3692. break;
3694. case 70102: // 선두
3695. case 70103: // 선두
3696. {
3697. if (GetAlignment() >= 0)
3698. return false;
3700. int delta = MIN(-GetAlignment(), item->GetValue(0));
3702. sys_log(0, "%s ALIGNMENT ITEM %d", GetName(), delta);
3704. UpdateAlignment(delta);
3705. item->SetCount(item->GetCount() - 1);
3707. if (delta / 10 > 0)
3708. {
3709. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("마음이 맑아지는군. 가슴을 짓누르던 무언가가 좀 가벼워진 느낌이야."));
3710. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치가 %d 증가하였습니다."), delta/10);
3711. }
3712. }
3713. break;
3715. case 71107: // 천도복숭아
3716. {
3717. int val = item->GetValue(0);
3718. int interval = item->GetValue(1);
3719. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
3720. int last_use_time = pPC->GetFlag("mythical_peach.last_use_time");
3722. if (get_global_time() - last_use_time < interval * 60 * 60)
3723. {
3724. if (test_server == false)
3725. {
3726. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 사용할 수 없습니다."));
3727. return false;
3728. }
3729. else
3730. {
3731. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("테스트 서버 시간제한 통과"));
3732. }
3733. }
3735. if (GetAlignment() == 200000)
3736. {
3737. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치를 더 이상 올릴 수 없습니다."));
3738. return false;
3739. }
3741. if (200000 - GetAlignment() < val * 10)
3742. {
3743. val = (200000 - GetAlignment()) / 10;
3744. }
3746. int old_alignment = GetAlignment() / 10;
3748. UpdateAlignment(val*10);
3750. item->SetCount(item->GetCount()-1);
3751. pPC->SetFlag("mythical_peach.last_use_time", get_global_time());
3753. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("마음이 맑아지는군. 가슴을 짓누르던 무언가가 좀 가벼워진 느낌이야."));
3754. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치가 %d 증가하였습니다."), val);
3756. char buf[256 + 1];
3757. snprintf(buf, sizeof(buf), "%d %d", old_alignment, GetAlignment() / 10);
3758. LogManager::instance().CharLog(this, val, "MYTHICAL_PEACH", buf);
3759. }
3760. break;
3762. case 71109: // 탈석서
3763. case 72719:
3764. {
3765. LPITEM item2;
3767. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
3768. return false;
3770. if (item2->IsExchanging() == true)
3771. return false;
3773. if (item2->GetSocketCount() == 0)
3774. return false;
3776. if (item2->IsEquipped())
3777. return false;
3779. switch( item2->GetType() )
3780. {
3781. case ITEM_WEAPON:
3782. break;
3783. case ITEM_ARMOR:
3784. switch (item2->GetSubType())
3785. {
3786. case ARMOR_EAR:
3787. case ARMOR_WRIST:
3788. case ARMOR_NECK:
3789. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 영석이 없습니다"));
3790. return false;
3791. }
3792. break;
3794. default:
3795. return false;
3796. }
3798. std::stack<long> socket;
3800. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
3801. socket.push(item2->GetSocket(i));
3803. int idx = ITEM_SOCKET_MAX_NUM - 1;
3805. while (socket.size() > 0)
3806. {
3807. if (socket.top() > 2 && socket.top() != ITEM_BROKEN_METIN_VNUM)
3808. break;
3810. idx--;
3811. socket.pop();
3812. }
3814. if (socket.size() == 0)
3815. {
3816. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 영석이 없습니다"));
3817. return false;
3818. }
3820. LPITEM pItemReward = AutoGiveItem(socket.top());
3822. if (pItemReward != NULL)
3823. {
3824. item2->SetSocket(idx, 1);
3826. char buf[256+1];
3827. snprintf(buf, sizeof(buf), "%s(%u) %s(%u)",
3828. item2->GetName(), item2->GetID(), pItemReward->GetName(), pItemReward->GetID());
3829. LogManager::instance().ItemLog(this, item, "USE_DETACHMENT_ONE", buf);
3831. item->SetCount(item->GetCount() - 1);
3832. }
3833. }
3834. break;
3836. case 70201: // 탈색제
3837. case 70202: // 염색약(흰색)
3838. case 70203: // 염색약(금색)
3839. case 70204: // 염색약(빨간색)
3840. case 70205: // 염색약(갈색)
3841. case 70206: // 염색약(검은색)
3842. {
3843. // NEW_HAIR_STYLE_ADD
3844. if (GetPart(PART_HAIR) >= 1001)
3845. {
3846. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("현재 헤어스타일에서는 염색과 탈색이 불가능합니다."));
3847. }
3848. // END_NEW_HAIR_STYLE_ADD
3849. else
3850. {
3851. quest::CQuestManager& q = quest::CQuestManager::instance();
3852. quest::PC* pPC = q.GetPC(GetPlayerID());
3854. if (pPC)
3855. {
3856. int last_dye_level = pPC->GetFlag("dyeing_hair.last_dye_level");
3858. if (last_dye_level == 0 ||
3859. last_dye_level+3 <= GetLevel() ||
3860. item->GetVnum() == 70201)
3861. {
3862. SetPart(PART_HAIR, item->GetVnum() - 70201);
3864. if (item->GetVnum() == 70201)
3865. pPC->SetFlag("dyeing_hair.last_dye_level", 0);
3866. else
3867. pPC->SetFlag("dyeing_hair.last_dye_level", GetLevel());
3869. item->SetCount(item->GetCount() - 1);
3870. UpdatePacket();
3871. }
3872. else
3873. {
3874. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d 레벨이 되어야 다시 염색하실 수 있습니다."), last_dye_level+3);
3875. }
3876. }
3877. }
3878. }
3879. break;
3881. case ITEM_NEW_YEAR_GREETING_VNUM:
3882. {
3883. DWORD dwBoxVnum = ITEM_NEW_YEAR_GREETING_VNUM;
3884. std::vector <DWORD> dwVnums;
3885. std::vector <DWORD> dwCounts;
3886. std::vector <LPITEM> item_gets;
3887. int count = 0;
3889. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
3890. {
3891. for (int i = 0; i < count; i++)
3892. {
3893. if (dwVnums[i] == CSpecialItemGroup::GOLD)
3894. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
3895. }
3897. item->SetCount(item->GetCount() - 1);
3898. }
3899. }
3900. break;
3902. case ITEM_VALENTINE_ROSE:
3903. case ITEM_VALENTINE_CHOCOLATE:
3904. {
3905. DWORD dwBoxVnum = item->GetVnum();
3906. std::vector <DWORD> dwVnums;
3907. std::vector <DWORD> dwCounts;
3908. std::vector <LPITEM> item_gets(NULL);
3909. int count = 0;
3912. if (item->GetVnum() == ITEM_VALENTINE_ROSE && SEX_MALE==GET_SEX(this) ||
3913. item->GetVnum() == ITEM_VALENTINE_CHOCOLATE && SEX_FEMALE==GET_SEX(this))
3914. {
3915. // 성별이 맞지않아 쓸 수 없다.
3916. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 열 수 없습니다."));
3917. return false;
3918. }
3921. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
3922. item->SetCount(item->GetCount()-1);
3923. }
3924. break;
3926. case ITEM_WHITEDAY_CANDY:
3927. case ITEM_WHITEDAY_ROSE:
3928. {
3929. DWORD dwBoxVnum = item->GetVnum();
3930. std::vector <DWORD> dwVnums;
3931. std::vector <DWORD> dwCounts;
3932. std::vector <LPITEM> item_gets(NULL);
3933. int count = 0;
3936. if (item->GetVnum() == ITEM_WHITEDAY_CANDY && SEX_MALE==GET_SEX(this) ||
3937. item->GetVnum() == ITEM_WHITEDAY_ROSE && SEX_FEMALE==GET_SEX(this))
3938. {
3939. // 성별이 맞지않아 쓸 수 없다.
3940. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 열 수 없습니다."));
3941. return false;
3942. }
3945. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
3946. item->SetCount(item->GetCount()-1);
3947. }
3948. break;
3950. case 50011: // 월광보합
3951. {
3952. DWORD dwBoxVnum = 50011;
3953. std::vector <DWORD> dwVnums;
3954. std::vector <DWORD> dwCounts;
3955. std::vector <LPITEM> item_gets(NULL);
3956. int count = 0;
3958. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
3959. {
3960. for (int i = 0; i < count; i++)
3961. {
3962. char buf[50 + 1];
3963. snprintf(buf, sizeof(buf), "%u %u", dwVnums[i], dwCounts[i]);
3964. LogManager::instance().ItemLog(this, item, "MOONLIGHT_GET", buf);
3966. //item->SetCount(item->GetCount() - 1);
3967. item->SetCount(item->GetCount() - 1);
3969. switch (dwVnums[i])
3970. {
3971. case CSpecialItemGroup::GOLD:
3972. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
3973. break;
3975. case CSpecialItemGroup::EXP:
3976. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
3977. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
3978. break;
3980. case CSpecialItemGroup::MOB:
3981. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
3982. break;
3984. case CSpecialItemGroup::SLOW:
3985. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
3986. break;
3988. case CSpecialItemGroup::DRAIN_HP:
3989. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
3990. break;
3992. case CSpecialItemGroup::POISON:
3993. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
3994. break;
3996. case CSpecialItemGroup::MOB_GROUP:
3997. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
3998. break;
4000. default:
4001. if (item_gets[i])
4002. {
4003. if (dwCounts[i] > 1)
4004. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
4005. else
4006. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
4007. }
4008. break;
4009. }
4010. }
4011. }
4012. else
4013. {
4014. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
4015. return false;
4016. }
4017. }
4018. break;
4020. case ITEM_GIVE_STAT_RESET_COUNT_VNUM:
4021. {
4022. //PointChange(POINT_GOLD, -iCost);
4023. PointChange(POINT_STAT_RESET_COUNT, 1);
4024. item->SetCount(item->GetCount()-1);
4025. }
4026. break;
4028. case 50107:
4029. {
4030. EffectPacket(SE_CHINA_FIREWORK);
4031. // 스턴 공격을 올려준다
4032. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
4033. item->SetCount(item->GetCount()-1);
4034. }
4035. break;
4037. case 50108:
4038. {
4039. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
4040. {
4041. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
4042. return false;
4043. }
4045. EffectPacket(SE_SPIN_TOP);
4046. // 스턴 공격을 올려준다
4047. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
4048. item->SetCount(item->GetCount()-1);
4049. }
4050. break;
4052. case ITEM_WONSO_BEAN_VNUM:
4053. PointChange(POINT_HP, GetMaxHP() - GetHP());
4054. item->SetCount(item->GetCount()-1);
4055. break;
4057. case ITEM_WONSO_SUGAR_VNUM:
4058. PointChange(POINT_SP, GetMaxSP() - GetSP());
4059. item->SetCount(item->GetCount()-1);
4060. break;
4062. case ITEM_WONSO_FRUIT_VNUM:
4063. PointChange(POINT_STAMINA, GetMaxStamina()-GetStamina());
4064. item->SetCount(item->GetCount()-1);
4065. break;
4067. case 90008: // VCARD
4068. case 90009: // VCARD
4069. VCardUse(this, this, item);
4070. break;
4072. case ITEM_ELK_VNUM: // 돈꾸러미
4073. {
4074. int iGold = item->GetSocket(0);
4075. item->SetCount(item->GetCount() - 1);
4076. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), iGold);
4077. PointChange(POINT_GOLD, iGold);
4078. }
4079. break;
4081. //군주의 증표
4082. case 70021:
4083. {
4084. int HealPrice = quest::CQuestManager::instance().GetEventFlag("MonarchHealGold");
4085. if (HealPrice == 0)
4086. HealPrice = 2000000;
4088. if (CMonarch::instance().HealMyEmpire(this, HealPrice))
4089. {
4090. char szNotice[256];
4091. snprintf(szNotice, sizeof(szNotice), LC_TEXT("군주의 축복으로 이지역 %s 유저는 HP,SP가 모두 채워집니다."), EMPIRE_NAME(GetEmpire()));
4092. SendNoticeMap(szNotice, GetMapIndex(), false);
4094. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군주의 축복을 사용하였습니다."));
4095. }
4096. }
4097. break;
4099. case 27995:
4100. {
4101. }
4102. break;
4104. case 71092 : // 변신 해체부 임시
4105. {
4106. if (m_pkChrTarget != NULL)
4107. {
4108. if (m_pkChrTarget->IsPolymorphed())
4109. {
4110. m_pkChrTarget->SetPolymorph(0);
4111. m_pkChrTarget->RemoveAffect(AFFECT_POLYMORPH);
4112. }
4113. }
4114. else
4115. {
4116. if (IsPolymorphed())
4117. {
4118. SetPolymorph(0);
4119. RemoveAffect(AFFECT_POLYMORPH);
4120. }
4121. }
4122. }
4123. break;
4125. case 71051 : // 진재가
4126. {
4127. // 유럽, 싱가폴, 베트남 진재가 사용금지
4128. //if (LC_IsEurope() || LC_IsSingapore() || LC_IsVietnam())
4129. //return false;
4131. LPITEM item2;
4133. if (!IsValidItemPosition(DestCell) || !(item2 = GetInventoryItem(wDestCell)))
4134. return false;
4136. if (item2->IsExchanging() == true)
4137. return false;
4139. if (item2->IsEquipped())
4140. {
4141. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[SYSTEM] Nu poti adauga bonusuri obiectelor echipate!"));
4142. return false;
4143. }
4144. //blocare bonus pe costume 6/7 dnd START
4145. if (item2->GetType() == ITEM_COSTUME)
4146. {
4147. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[SYSTEM] Nu poti atribuii bonusuri unui costum!"));
4148. return false;
4149. }
4150. //blocare bonus pe costume 6/7 dnd END
4151. if (item2->GetAttributeSetIndex() == -1)
4152. {
4153. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[SYSTEM] Nu poti adauga mai multe bonusuri speciale!"));
4154. return false;
4155. }
4157. if (item2->AddRareAttribute() == true)
4158. {
4159. //ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[SYSTEM] Ai adaugat bonusul cu succes!"));
4161. int iAddedIdx = item2->GetRareAttrCount() + 4;
4162. char buf[21];
4163. snprintf(buf, sizeof(buf), "%u", item2->GetID());
4165. LogManager::instance().ItemLog(
4166. GetPlayerID(),
4167. item2->GetAttributeType(iAddedIdx),
4168. item2->GetAttributeValue(iAddedIdx),
4169. item->GetID(),
4170. "ADD_RARE_ATTR",
4171. buf,
4172. GetDesc()->GetHostName(),
4173. item->GetOriginalVnum());
4175. item->SetCount(item->GetCount() - 1);
4176. }
4177. else
4178. {
4179. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[SYSTEM] Nu poti adauga mai multe bonusuri speciale!"));
4180. }
4181. }
4182. break;
4184. case 71052 : // 진재경
4185. {
4186. // 유럽, 싱가폴, 베트남 진재가 사용금지
4187. //if (LC_IsEurope() || LC_IsSingapore() || LC_IsVietnam())
4188. //return false;
4190. LPITEM item2;
4192. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
4193. return false;
4195. if (item2->IsExchanging() == true)
4196. return false;
4198. if (item2->GetAttributeSetIndex() == -1)
4199. {
4200. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
4201. return false;
4202. }
4204. if (item2->IsEquipped())
4205. {
4206. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[SYSTEM] Nu poti schimba bonusurile obiectelor echipate!"));
4207. return false;
4208. }
4210. if (item2->ChangeRareAttribute() == true)
4211. {
4212. char buf[21];
4213. snprintf(buf, sizeof(buf), "%u", item2->GetID());
4214. LogManager::instance().ItemLog(this, item, "CHANGE_RARE_ATTR", buf);
4216. item->SetCount(item->GetCount() - 1);
4217. }
4218. else
4219. {
4220. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변경 시킬 속성이 없습니다"));
4221. }
4222. }
4223. break;
4225. case ITEM_AUTO_HP_RECOVERY_S:
4226. case ITEM_AUTO_HP_RECOVERY_M:
4227. case ITEM_AUTO_HP_RECOVERY_L:
4228. case ITEM_AUTO_HP_RECOVERY_X:
4229. case ITEM_AUTO_SP_RECOVERY_S:
4230. case ITEM_AUTO_SP_RECOVERY_M:
4231. case ITEM_AUTO_SP_RECOVERY_L:
4232. case ITEM_AUTO_SP_RECOVERY_X:
4233. // 무시무시하지만 이전에 하던 걸 고치기는 무섭고...
4234. // 그래서 그냥 하드 코딩. 선물 상자용 자동물약 아이템들.
4235. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
4236. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
4237. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
4238. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
4239. case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
4240. case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
4241. if (FindAffect(AFFECT_ITEM_BLOCK))
4242. {
4243. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<Sistem> Trebuie sa astepti 5 secunde pentru a putea face asta!"));
4244. return false;
4245. }
4246. {
4247. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
4248. {
4249. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
4250. return false;
4251. }
4253. EAffectTypes type = AFFECT_NONE;
4254. bool isSpecialPotion = false;
4256. switch (item->GetVnum())
4257. {
4258. case ITEM_AUTO_HP_RECOVERY_X:
4259. isSpecialPotion = true;
4261. case ITEM_AUTO_HP_RECOVERY_S:
4262. case ITEM_AUTO_HP_RECOVERY_M:
4263. case ITEM_AUTO_HP_RECOVERY_L:
4264. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
4265. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
4266. case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
4267. type = AFFECT_AUTO_HP_RECOVERY;
4268. break;
4270. case ITEM_AUTO_SP_RECOVERY_X:
4271. isSpecialPotion = true;
4273. case ITEM_AUTO_SP_RECOVERY_S:
4274. case ITEM_AUTO_SP_RECOVERY_M:
4275. case ITEM_AUTO_SP_RECOVERY_L:
4276. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
4277. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
4278. case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
4279. type = AFFECT_AUTO_SP_RECOVERY;
4280. break;
4281. }
4283. if (AFFECT_NONE == type)
4284. break;
4286. if (item->GetCount() > 1)
4287. {
4288. int pos = GetEmptyInventory(item->GetSize());
4290. if (-1 == pos)
4291. {
4292. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
4293. break;
4294. }
4296. item->SetCount( item->GetCount() - 1 );
4298. LPITEM item2 = ITEM_MANAGER::instance().CreateItem( item->GetVnum(), 1 );
4299. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
4301. if (item->GetSocket(1) != 0)
4302. {
4303. item2->SetSocket(1, item->GetSocket(1));
4304. }
4306. item = item2;
4307. }
4309. CAffect* pAffect = FindAffect( type );
4311. if (NULL == pAffect)
4312. {
4313. EPointTypes bonus = POINT_NONE;
4315. if (true == isSpecialPotion)
4316. {
4317. if (type == AFFECT_AUTO_HP_RECOVERY)
4318. {
4319. bonus = POINT_MAX_HP_PCT;
4320. }
4321. else if (type == AFFECT_AUTO_SP_RECOVERY)
4322. {
4323. bonus = POINT_MAX_SP_PCT;
4324. }
4325. }
4327. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
4329. item->Lock(true);
4330. item->SetSocket(0, true);
4332. AutoRecoveryItemProcess( type );
4333. AddAffect(AFFECT_ITEM_BLOCK, POINT_NONE, 0, 0, 5, 0, true, false);
4334. }
4335. else
4336. {
4337. if (item->GetID() == pAffect->dwFlag)
4338. {
4339. RemoveAffect( pAffect );
4341. item->Lock(false);
4342. item->SetSocket(0, false);
4343. }
4344. else
4345. {
4346. LPITEM old = FindItemByID( pAffect->dwFlag );
4348. if (NULL != old)
4349. {
4350. old->Lock(false);
4351. old->SetSocket(0, false);
4352. }
4354. RemoveAffect( pAffect );
4356. EPointTypes bonus = POINT_NONE;
4358. if (true == isSpecialPotion)
4359. {
4360. if (type == AFFECT_AUTO_HP_RECOVERY)
4361. {
4362. bonus = POINT_MAX_HP_PCT;
4363. }
4364. else if (type == AFFECT_AUTO_SP_RECOVERY)
4365. {
4366. bonus = POINT_MAX_SP_PCT;
4367. }
4368. }
4370. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
4372. item->Lock(true);
4373. item->SetSocket(0, true);
4375. AutoRecoveryItemProcess( type );
4376. }
4377. }
4378. }
4379. break;
4380. }
4381. break;
4383. case USE_CLEAR:
4384. {
4385. RemoveBadAffect();
4386. item->SetCount(item->GetCount() - 1);
4387. }
4388. break;
4390. case USE_INVISIBILITY:
4391. {
4392. if (item->GetVnum() == 70026)
4393. {
4394. quest::CQuestManager& q = quest::CQuestManager::instance();
4395. quest::PC* pPC = q.GetPC(GetPlayerID());
4397. if (pPC != NULL)
4398. {
4399. int last_use_time = pPC->GetFlag("mirror_of_disapper.last_use_time");
4401. if (get_global_time() - last_use_time < 10*60)
4402. {
4403. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 사용할 수 없습니다."));
4404. return false;
4405. }
4407. pPC->SetFlag("mirror_of_disapper.last_use_time", get_global_time());
4408. }
4409. }
4411. AddAffect(AFFECT_INVISIBILITY, POINT_NONE, 0, AFF_INVISIBILITY, 300, 0, true);
4412. item->SetCount(item->GetCount() - 1);
4413. }
4414. break;
4416. case USE_POTION_NODELAY:
4417. {
4418. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
4419. {
4420. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
4421. {
4422. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
4423. return false;
4424. }
4426. switch (item->GetVnum())
4427. {
4428. case 70020 :
4429. case 71018 :
4430. case 71019 :
4431. case 71020 :
4432. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
4433. {
4434. if (m_nPotionLimit <= 0)
4435. {
4436. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
4437. return false;
4438. }
4439. }
4440. break;
4442. default :
4443. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
4444. return false;
4445. }
4446. }
4448. bool used = false;
4450. if (item->GetValue(0) != 0) // HP 절대값 회복
4451. {
4452. if (GetHP() < GetMaxHP())
4453. {
4454. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
4455. EffectPacket(SE_HPUP_RED);
4456. used = TRUE;
4457. }
4458. }
4460. if (item->GetValue(1) != 0) // SP 절대값 회복
4461. {
4462. if (GetSP() < GetMaxSP())
4463. {
4464. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
4465. EffectPacket(SE_SPUP_BLUE);
4466. used = TRUE;
4467. }
4468. }
4470. if (item->GetValue(3) != 0) // HP % 회복
4471. {
4472. if (GetHP() < GetMaxHP())
4473. {
4474. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
4475. EffectPacket(SE_HPUP_RED);
4476. used = TRUE;
4477. }
4478. }
4480. if (item->GetValue(4) != 0) // SP % 회복
4481. {
4482. if (GetSP() < GetMaxSP())
4483. {
4484. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
4485. EffectPacket(SE_SPUP_BLUE);
4486. used = TRUE;
4487. }
4488. }
4490. if (used)
4491. {
4492. if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
4493. {
4494. if (test_server)
4495. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("월병 또는 종자 를 사용하였습니다"));
4496. SetUseSeedOrMoonBottleTime();
4497. }
4498. if (GetDungeon())
4499. GetDungeon()->UsePotion(this);
4501. if (GetWarMap())
4502. GetWarMap()->UsePotion(this, item);
4504. m_nPotionLimit--;
4506. //RESTRICT_USE_SEED_OR_MOONBOTTLE
4507. item->SetCount(item->GetCount() - 1);
4508. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
4509. }
4510. }
4511. break;
4513. case USE_POTION:
4514. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
4515. {
4516. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
4517. {
4518. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
4519. return false;
4520. }
4522. switch (item->GetVnum())
4523. {
4524. case 27001 :
4525. case 27002 :
4526. case 27003 :
4527. case 27004 :
4528. case 27005 :
4529. case 27006 :
4530. case 40489 :
4531. case 40490 :
4532. case 40491 :
4533. case 40492 :
4534. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
4535. {
4536. if (m_nPotionLimit <= 0)
4537. {
4538. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
4539. return false;
4540. }
4541. }
4542. break;
4544. default :
4545. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
4546. return false;
4547. }
4548. }
4550. if (item->GetValue(1) != 0)
4551. {
4552. if (GetPoint(POINT_SP_RECOVERY) + GetSP() >= GetMaxSP())
4553. {
4554. return false;
4555. }
4557. PointChange(POINT_SP_RECOVERY, item->GetValue(1) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
4558. StartAffectEvent();
4559. EffectPacket(SE_SPUP_BLUE);
4560. }
4562. if (item->GetValue(0) != 0)
4563. {
4564. if (GetPoint(POINT_HP_RECOVERY) + GetHP() >= GetMaxHP())
4565. {
4566. return false;
4567. }
4569. PointChange(POINT_HP_RECOVERY, item->GetValue(0) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
4570. StartAffectEvent();
4571. EffectPacket(SE_HPUP_RED);
4572. }
4574. if (GetDungeon())
4575. GetDungeon()->UsePotion(this);
4577. if (GetWarMap())
4578. GetWarMap()->UsePotion(this, item);
4580. item->SetCount(item->GetCount() - 1);
4581. m_nPotionLimit--;
4582. break;
4584. case USE_POTION_CONTINUE:
4585. {
4586. if (item->GetValue(0) != 0)
4587. {
4588. AddAffect(AFFECT_HP_RECOVER_CONTINUE, POINT_HP_RECOVER_CONTINUE, item->GetValue(0), 0, item->GetValue(2), 0, true);
4589. }
4590. else if (item->GetValue(1) != 0)
4591. {
4592. AddAffect(AFFECT_SP_RECOVER_CONTINUE, POINT_SP_RECOVER_CONTINUE, item->GetValue(1), 0, item->GetValue(2), 0, true);
4593. }
4594. else
4595. return false;
4596. }
4598. if (GetDungeon())
4599. GetDungeon()->UsePotion(this);
4601. if (GetWarMap())
4602. GetWarMap()->UsePotion(this, item);
4604. item->SetCount(item->GetCount() - 1);
4605. break;
4607. case USE_ABILITY_UP:
4608. #ifdef ENABLE_YMIR_AFFECT_FIX
4609. if ((CheckTimeUsed(item) == false)) { return false; }
4610. #endif
4611. {
4612. switch (item->GetValue(0))
4613. {
4614. case APPLY_MOV_SPEED:
4615. if (FindAffect(AFFECT_MOV_SPEED))
4616. {
4617. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<System> Folosesti deja un efect de viteza"));
4618. return false;
4619. }
4620. AddAffect(AFFECT_MOV_SPEED, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true);
4621. break;
4623. case APPLY_ATT_SPEED:
4624. if (FindAffect(AFFECT_ATT_SPEED))
4625. {
4626. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<System> Folosesti deja un efect de viteza"));
4627. return false;
4628. }
4629. AddAffect(AFFECT_ATT_SPEED, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true);
4630. break;
4632. case APPLY_STR:
4633. AddAffect(AFFECT_STR, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true);
4634. break;
4636. case APPLY_DEX:
4637. AddAffect(AFFECT_DEX, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true);
4638. break;
4640. case APPLY_CON:
4641. AddAffect(AFFECT_CON, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true);
4642. break;
4644. case APPLY_INT:
4645. AddAffect(AFFECT_INT, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true);
4646. break;
4648. case APPLY_CAST_SPEED:
4649. AddAffect(AFFECT_CAST_SPEED, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true);
4650. break;
4652. case APPLY_ATT_GRADE_BONUS:
4653. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE_BONUS,
4654. item->GetValue(2), 0, item->GetValue(1), 0, true);
4655. break;
4657. case APPLY_DEF_GRADE_BONUS:
4658. AddAffect(AFFECT_DEF_GRADE, POINT_DEF_GRADE_BONUS,
4659. item->GetValue(2), 0, item->GetValue(1), 0, true);
4660. break;
4661. }
4662. }
4664. if (GetDungeon())
4665. GetDungeon()->UsePotion(this);
4667. if (GetWarMap())
4668. GetWarMap()->UsePotion(this, item);
4670. item->SetCount(item->GetCount() - 1);
4671. break;
4673. case USE_TALISMAN:
4674. {
4675. const int TOWN_PORTAL = 1;
4676. const int MEMORY_PORTAL = 2;
4679. // gm_guild_build, oxevent 맵에서 귀환부 귀환기억부 를 사용못하게 막음
4680. if (GetMapIndex() == 200 || GetMapIndex() == 113)
4681. {
4682. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("현재 위치에서 사용할 수 없습니다."));
4683. return false;
4684. }
4686. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
4687. {
4688. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
4689. return false;
4690. }
4692. if (m_pkWarpEvent)
4693. {
4694. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이동할 준비가 되어있음으로 귀환부를 사용할수 없습니다"));
4695. return false;
4696. }
4698. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
4699. int consumeLife = CalculateConsume(this);
4701. if (consumeLife < 0)
4702. return false;
4703. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
4705. if (item->GetValue(0) == TOWN_PORTAL) // 귀환부
4706. {
4707. if (item->GetSocket(0) == 0)
4708. {
4709. if (!GetDungeon())
4710. if (!GiveRecallItem(item))
4711. return false;
4713. PIXEL_POSITION posWarp;
4715. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp))
4716. {
4717. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
4718. PointChange(POINT_HP, -consumeLife, false);
4719. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
4721. WarpSet(posWarp.x, posWarp.y);
4722. }
4723. else
4724. {
4725. sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", GetName(), GetX(), GetY());
4726. }
4727. }
4728. else
4729. {
4730. if (test_server)
4731. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("원래 위치로 복귀"));
4733. ProcessRecallItem(item);
4734. }
4735. }
4736. else if (item->GetValue(0) == MEMORY_PORTAL) // 귀환기억부
4737. {
4738. if (item->GetSocket(0) == 0)
4739. {
4740. if (GetDungeon())
4741. {
4742. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("던전 안에서는 %s%s 사용할 수 없습니다."),
4743. item->GetName(),
4744. g_iUseLocale ? "" : (under_han(item->GetName()) ? LC_TEXT("을") : LC_TEXT("를")));
4745. return false;
4746. }
4748. if (!GiveRecallItem(item))
4749. return false;
4750. }
4751. else
4752. {
4753. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
4754. PointChange(POINT_HP, -consumeLife, false);
4755. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
4757. ProcessRecallItem(item);
4758. }
4759. }
4760. }
4761. break;
4763. case USE_TUNING:
4764. case USE_DETACHMENT:
4765. {
4766. LPITEM item2;
4768. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
4769. return false;
4771. if (item2->IsExchanging())
4772. return false;
4774. if (item2->IsEquipped())
4775. return false;
4777. #ifdef __SASH_SYSTEM__
4778. if (item->GetValue(0) == SASH_CLEAN_ATTR_VALUE0)
4779. {
4780. if (!CleanSashAttr(item, item2))
4781. return false;
4783. return true;
4784. }
4785. #endif
4787. if (item2->GetVnum() >= 28330 && item2->GetVnum() <= 28343) // 영석+3
4788. {
4789. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("+3 영석은 이 아이템으로 개량할 수 없습니다"));
4790. return false;
4791. }
4793. if (item2->GetVnum() >= 28430 && item2->GetVnum() <= 28443) // 영석+4
4794. {
4795. if (item->GetVnum() == 71056) // 청룡의숨결
4796. {
4797. RefineItem(item, item2);
4798. }
4799. else
4800. {
4801. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("영석은 이 아이템으로 개량할 수 없습니다"));
4802. }
4803. }
4804. else
4805. {
4806. RefineItem(item, item2);
4807. }
4808. }
4809. break;
4811. // ACCESSORY_REFINE & ADD/CHANGE_ATTRIBUTES
4812. case USE_PUT_INTO_BELT_SOCKET:
4813. case USE_PUT_INTO_RING_SOCKET:
4814. case USE_PUT_INTO_ACCESSORY_SOCKET:
4815. case USE_ADD_ACCESSORY_SOCKET:
4816. case USE_CLEAN_SOCKET:
4817. case USE_CHANGE_ATTRIBUTE:
4818. case USE_CHANGE_ATTRIBUTE2 :
4819. case USE_ADD_ATTRIBUTE:
4820. case USE_ADD_ATTRIBUTE2:
4821. {
4822. LPITEM item2;
4823. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
4824. return false;
4826. if (item2->IsEquipped())
4827. {
4828. BuffOnAttr_RemoveBuffsFromItem(item2);
4829. }
4831. // [NOTE] 코스튬 아이템에는 아이템 최초 생성시 랜덤 속성을 부여하되, 재경재가 등등은 막아달라는 요청이 있었음.
4832. // 원래 ANTI_CHANGE_ATTRIBUTE 같은 아이템 Flag를 추가하여 기획 레벨에서 유연하게 컨트롤 할 수 있도록 할 예정이었으나
4833. // 그딴거 필요없으니 닥치고 빨리 해달래서 그냥 여기서 막음... -_-
4834. if (ITEM_COSTUME == item2->GetType())
4835. {
4836. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
4837. return false;
4838. }
4840. if (item2->IsExchanging())
4841. return false;
4843. switch (item->GetSubType())
4844. {
4845. case USE_CLEAN_SOCKET:
4846. {
4847. int i;
4848. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
4849. {
4850. if (item2->GetSocket(i) == ITEM_BROKEN_METIN_VNUM)
4851. break;
4852. }
4854. if (i == ITEM_SOCKET_MAX_NUM)
4855. {
4856. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("청소할 석이 박혀있지 않습니다."));
4857. return false;
4858. }
4860. int j = 0;
4862. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
4863. {
4864. if (item2->GetSocket(i) != ITEM_BROKEN_METIN_VNUM && item2->GetSocket(i) != 0)
4865. item2->SetSocket(j++, item2->GetSocket(i));
4866. }
4868. for (; j < ITEM_SOCKET_MAX_NUM; ++j)
4869. {
4870. if (item2->GetSocket(j) > 0)
4871. item2->SetSocket(j, 1);
4872. }
4874. {
4875. char buf[21];
4876. snprintf(buf, sizeof(buf), "%u", item2->GetID());
4877. LogManager::instance().ItemLog(this, item, "CLEAN_SOCKET", buf);
4878. }
4880. item->SetCount(item->GetCount() - 1);
4882. }
4883. break;
4885. case USE_CHANGE_ATTRIBUTE :
4886. if (item2->GetAttributeSetIndex() == -1)
4887. {
4888. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
4889. return false;
4890. }
4892. if (item2->IsEquipped()){
4893. ChatPacket(CHAT_TYPE_INFO, "[SYSTEM] Nu poti schimba bonusurile obiectelor echipate!");
4894. return false;
4895. }
4897. if (item2->GetAttributeCount() == 0)
4898. {
4899. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변경할 속성이 없습니다."));
4900. return false;
4901. }
4903. if (GM_PLAYER == GetGMLevel() && false == test_server)
4904. {
4905. //
4906. // Event Flag 를 통해 이전에 아이템 속성 변경을 한 시간으로 부터 충분한 시간이 흘렀는지 검사하고
4907. // 시간이 충분히 흘렀다면 현재 속성변경에 대한 시간을 설정해 준다.
4908. //
4910. DWORD dwChangeItemAttrCycle = quest::CQuestManager::instance().GetEventFlag(msc_szChangeItemAttrCycleFlag);
4911. if (dwChangeItemAttrCycle < msc_dwDefaultChangeItemAttrCycle)
4912. dwChangeItemAttrCycle = msc_dwDefaultChangeItemAttrCycle;
4914. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
4916. if (pPC)
4917. {
4918. DWORD dwNowMin = get_global_time() / 60;
4920. //DWORD dwLastChangeItemAttrMin = pPC->GetFlag(msc_szLastChangeItemAttrFlag);
4922. //if (dwLastChangeItemAttrMin + dwChangeItemAttrCycle > dwNowMin)
4923. //{
4924. //ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 바꾼지 %d분 이내에는 다시 변경할 수 없습니다.(%d 분 남음)"),
4925. //dwChangeItemAttrCycle, dwChangeItemAttrCycle - (dwNowMin - dwLastChangeItemAttrMin));
4928. pPC->SetFlag(msc_szLastChangeItemAttrFlag, dwNowMin);
4929. }
4930. }
4932. if (item->GetSubType() == USE_CHANGE_ATTRIBUTE2)
4933. {
4934. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
4935. {
4936. 0, 0, 30, 40, 3
4937. };
4939. item2->ChangeAttribute(aiChangeProb);
4940. }
4941. else if (item->GetVnum() == 76014)
4942. {
4943. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
4944. {
4945. 0, 10, 50, 39, 1
4946. };
4948. item2->ChangeAttribute(aiChangeProb);
4949. }
4951. else
4952. {
4953. // 연재경 특수처리
4954. // 절대로 연재가 추가 안될거라 하여 하드 코딩함.
4955. if (item->GetVnum() == 71151 || item->GetVnum() == 76023)
4956. {
4957. if ((item2->GetType() == ITEM_WEAPON)
4958. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
4959. {
4960. bool bCanUse = true;
4961. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
4962. {
4963. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
4964. {
4965. bCanUse = false;
4966. break;
4967. }
4968. }
4969. if (false == bCanUse)
4970. {
4971. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적용 레벨보다 높아 사용이 불가능합니다."));
4972. break;
4973. }
4974. }
4975. else
4976. {
4977. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무기와 갑옷에만 사용 가능합니다."));
4978. break;
4979. }
4980. }
4981. item2->ChangeAttribute();
4982. }
4984. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경하였습니다."));
4985. {
4986. char buf[21];
4987. snprintf(buf, sizeof(buf), "%u", item2->GetID());
4988. LogManager::instance().ItemLog(this, item, "CHANGE_ATTRIBUTE", buf);
4989. }
4991. item->SetCount(item->GetCount() - 1);
4992. break;
4994. case USE_ADD_ATTRIBUTE :
4995. if (item2->GetAttributeSetIndex() == -1)
4996. {
4997. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
4998. return false;
4999. }
5001. if (item2->GetAttributeCount() < 4)
5002. {
5003. // 연재가 특수처리
5004. // 절대로 연재가 추가 안될거라 하여 하드 코딩함.
5005. if (item->GetVnum() == 71152 || item->GetVnum() == 76024)
5006. {
5007. if ((item2->GetType() == ITEM_WEAPON)
5008. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
5009. {
5010. bool bCanUse = true;
5011. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
5012. {
5013. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
5014. {
5015. bCanUse = false;
5016. break;
5017. }
5018. }
5019. if (false == bCanUse)
5020. {
5021. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적용 레벨보다 높아 사용이 불가능합니다."));
5022. break;
5023. }
5024. }
5025. else
5026. {
5027. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무기와 갑옷에만 사용 가능합니다."));
5028. break;
5029. }
5030. }
5031. char buf[21];
5032. snprintf(buf, sizeof(buf), "%u", item2->GetID());
5034. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
5035. {
5036. item2->AddAttribute();
5037. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 성공하였습니다."));
5039. int iAddedIdx = item2->GetAttributeCount() - 1;
5040. LogManager::instance().ItemLog(
5041. GetPlayerID(),
5042. item2->GetAttributeType(iAddedIdx),
5043. item2->GetAttributeValue(iAddedIdx),
5044. item->GetID(),
5045. "ADD_ATTRIBUTE_SUCCESS",
5046. buf,
5047. GetDesc()->GetHostName(),
5048. item->GetOriginalVnum());
5049. }
5050. else
5051. {
5052. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 실패하였습니다."));
5053. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE_FAIL", buf);
5054. }
5056. item->SetCount(item->GetCount() - 1);
5057. }
5058. else
5059. {
5060. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더이상 이 아이템을 이용하여 속성을 추가할 수 없습니다."));
5061. }
5062. break;
5064. case USE_ADD_ATTRIBUTE2 :
5065. // 축복의 구슬
5066. // 재가비서를 통해 속성을 4개 추가 시킨 아이템에 대해서 하나의 속성을 더 붙여준다.
5067. if (item2->GetAttributeSetIndex() == -1)
5068. {
5069. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
5070. return false;
5071. }
5073. // 속성이 이미 4개 추가 되었을 때만 속성을 추가 가능하다.
5074. if (item2->GetAttributeCount() == 4)
5075. {
5076. char buf[21];
5077. snprintf(buf, sizeof(buf), "%u", item2->GetID());
5079. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
5080. {
5081. item2->AddAttribute();
5082. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 성공하였습니다."));
5084. int iAddedIdx = item2->GetAttributeCount() - 1;
5085. LogManager::instance().ItemLog(
5086. GetPlayerID(),
5087. item2->GetAttributeType(iAddedIdx),
5088. item2->GetAttributeValue(iAddedIdx),
5089. item->GetID(),
5090. "ADD_ATTRIBUTE2_SUCCESS",
5091. buf,
5092. GetDesc()->GetHostName(),
5093. item->GetOriginalVnum());
5094. }
5095. else
5096. {
5097. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 실패하였습니다."));
5098. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE2_FAIL", buf);
5099. }
5101. item->SetCount(item->GetCount() - 1);
5102. }
5103. else if (item2->GetAttributeCount() == 5)
5104. {
5105. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 이 아이템을 이용하여 속성을 추가할 수 없습니다."));
5106. }
5107. else if (item2->GetAttributeCount() < 4)
5108. {
5109. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("먼저 재가비서를 이용하여 속성을 추가시켜 주세요."));
5110. }
5111. else
5112. {
5113. // wtf ?!
5114. sys_err("ADD_ATTRIBUTE2 : Item has wrong AttributeCount(%d)", item2->GetAttributeCount());
5115. }
5116. break;
5118. case USE_ADD_ACCESSORY_SOCKET:
5119. {
5120. char buf[21];
5121. snprintf(buf, sizeof(buf), "%u", item2->GetID());
5123. if (item2->IsAccessoryForSocket())
5124. {
5125. if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
5126. {
5127. if (number(1, 100) <= 50)
5128. {
5129. item2->SetAccessorySocketMaxGrade(item2->GetAccessorySocketMaxGrade() + 1);
5130. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소켓이 성공적으로 추가되었습니다."));
5131. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_SUCCESS", buf);
5132. }
5133. else
5134. {
5135. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소켓 추가에 실패하였습니다."));
5136. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_FAIL", buf);
5137. }
5139. item->SetCount(item->GetCount() - 1);
5140. }
5141. else
5142. {
5143. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 소켓을 추가할 공간이 없습니다."));
5144. }
5145. }
5146. else
5147. {
5148. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템으로 소켓을 추가할 수 없는 아이템입니다."));
5149. }
5150. }
5151. break;
5153. case USE_PUT_INTO_BELT_SOCKET:
5154. case USE_PUT_INTO_ACCESSORY_SOCKET:
5155. if (item2->IsAccessoryForSocket() && item->CanPutInto(item2))
5156. {
5157. char buf[21];
5158. snprintf(buf, sizeof(buf), "%u", item2->GetID());
5160. if (item2->GetAccessorySocketGrade() < item2->GetAccessorySocketMaxGrade())
5161. {
5162. if (number(1, 100) <= aiAccessorySocketPutPct[item2->GetAccessorySocketGrade()])
5163. {
5164. item2->SetAccessorySocketGrade(item2->GetAccessorySocketGrade() + 1);
5165. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장착에 성공하였습니다."));
5166. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_SUCCESS", buf);
5167. }
5168. else
5169. {
5170. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장착에 실패하였습니다."));
5171. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_FAIL", buf);
5172. }
5174. item->SetCount(item->GetCount() - 1);
5175. }
5176. else
5177. {
5178. if (item2->GetAccessorySocketMaxGrade() == 0)
5179. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("먼저 다이아몬드로 악세서리에 소켓을 추가해야합니다."));
5180. else if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
5181. {
5182. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 장착할 소켓이 없습니다."));
5183. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다이아몬드로 소켓을 추가해야합니다."));
5184. }
5185. else
5186. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 보석을 장착할 수 없습니다."));
5187. }
5188. }
5189. else
5190. {
5191. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템을 장착할 수 없습니다."));
5192. }
5193. break;
5194. }
5195. if (item2->IsEquipped())
5196. {
5197. BuffOnAttr_AddBuffsFromItem(item2);
5198. }
5199. }
5200. break;
5201. // END_OF_ACCESSORY_REFINE & END_OF_ADD_ATTRIBUTES & END_OF_CHANGE_ATTRIBUTES
5203. case USE_BAIT:
5204. {
5206. if (m_pkFishingEvent)
5207. {
5208. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시 중에 미끼를 갈아끼울 수 없습니다."));
5209. return false;
5210. }
5212. LPITEM weapon = GetWear(WEAR_WEAPON);
5214. if (!weapon || weapon->GetType() != ITEM_ROD)
5215. return false;
5217. if (weapon->GetSocket(2))
5218. {
5219. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 꽂혀있던 미끼를 빼고 %s를 끼웁니다."), item->GetName());
5220. }
5221. else
5222. {
5223. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시대에 %s를 미끼로 끼웁니다."), item->GetName());
5224. }
5226. weapon->SetSocket(2, item->GetValue(0));
5227. item->SetCount(item->GetCount() - 1);
5228. }
5229. break;
5231. case USE_MOVE:
5232. case USE_TREASURE_BOX:
5233. case USE_MONEYBAG:
5234. break;
5236. case USE_AFFECT :
5237. {
5238. if (FindAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType))
5239. {
5240. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
5241. }
5242. else
5243. {
5244. // PC_BANG_ITEM_ADD
5245. if (item->IsPCBangItem() == true)
5246. {
5247. // PC방인지 체크해서 처리
5248. if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
5249. {
5250. // PC방이 아님!
5251. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 PC방에서만 사용할 수 있습니다."));
5252. return false;
5253. }
5254. }
5255. // END_PC_BANG_ITEM_ADD
5257. AddAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false);
5258. item->SetCount(item->GetCount() - 1);
5259. }
5260. }
5261. break;
5263. case USE_CREATE_STONE:
5264. AutoGiveItem(number(28000, 28013));
5265. item->SetCount(item->GetCount() - 1);
5266. break;
5268. // 물약 제조 스킬용 레시피 처리
5269. case USE_RECIPE :
5270. {
5271. LPITEM pSource1 = FindSpecifyItem(item->GetValue(1));
5272. DWORD dwSourceCount1 = item->GetValue(2);
5274. LPITEM pSource2 = FindSpecifyItem(item->GetValue(3));
5275. DWORD dwSourceCount2 = item->GetValue(4);
5277. if (dwSourceCount1 != 0)
5278. {
5279. if (pSource1 == NULL)
5280. {
5281. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 조합을 위한 재료가 부족합니다."));
5282. return false;
5283. }
5284. }
5286. if (dwSourceCount2 != 0)
5287. {
5288. if (pSource2 == NULL)
5289. {
5290. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 조합을 위한 재료가 부족합니다."));
5291. return false;
5292. }
5293. }
5295. if (pSource1 != NULL)
5296. {
5297. if (pSource1->GetCount() < dwSourceCount1)
5298. {
5299. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("재료(%s)가 부족합니다."), pSource1->GetName());
5300. return false;
5301. }
5303. pSource1->SetCount(pSource1->GetCount() - dwSourceCount1);
5304. }
5306. if (pSource2 != NULL)
5307. {
5308. if (pSource2->GetCount() < dwSourceCount2)
5309. {
5310. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("재료(%s)가 부족합니다."), pSource2->GetName());
5311. return false;
5312. }
5314. pSource2->SetCount(pSource2->GetCount() - dwSourceCount2);
5315. }
5317. LPITEM pBottle = FindSpecifyItem(50901);
5319. if (!pBottle || pBottle->GetCount() < 1)
5320. {
5321. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빈 병이 모자릅니다."));
5322. return false;
5323. }
5325. pBottle->SetCount(pBottle->GetCount() - 1);
5327. if (number(1, 100) > item->GetValue(5))
5328. {
5329. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 제조에 실패했습니다."));
5330. return false;
5331. }
5333. AutoGiveItem(item->GetValue(0));
5334. }
5335. break;
5336. }
5337. }
5338. break;
5340. case ITEM_METIN:
5341. {
5342. LPITEM item2;
5344. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
5345. return false;
5347. if (item2->IsExchanging())
5348. return false;
5350. if (item2->GetType() == ITEM_PICK) return false;
5351. if (item2->GetType() == ITEM_ROD) return false;
5353. int i;
5355. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
5356. {
5357. DWORD dwVnum;
5359. if ((dwVnum = item2->GetSocket(i)) <= 2)
5360. continue;
5362. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwVnum);
5364. if (!p)
5365. continue;
5367. if (item->GetValue(5) == p->alValues[5])
5368. {
5369. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 종류의 메틴석은 여러개 부착할 수 없습니다."));
5370. return false;
5371. }
5372. }
5374. if (item2->GetType() == ITEM_ARMOR)
5375. {
5376. if (!IS_SET(item->GetWearFlag(), WEARABLE_BODY) || !IS_SET(item2->GetWearFlag(), WEARABLE_BODY))
5377. {
5378. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 메틴석은 장비에 부착할 수 없습니다."));
5379. return false;
5380. }
5381. }
5382. else if (item2->GetType() == ITEM_WEAPON)
5383. {
5384. if (!IS_SET(item->GetWearFlag(), WEARABLE_WEAPON))
5385. {
5386. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 메틴석은 무기에 부착할 수 없습니다."));
5387. return false;
5388. }
5389. }
5390. else
5391. {
5392. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("부착할 수 있는 슬롯이 없습니다."));
5393. return false;
5394. }
5396. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
5397. if (item2->GetSocket(i) >= 1 && item2->GetSocket(i) <= 2 && item2->GetSocket(i) >= item->GetValue(2))
5398. {
5399. // 석 확률
5400. if (number(1, 100) <= 30)
5401. {
5402. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 성공하였습니다."));
5403. item2->SetSocket(i, item->GetVnum());
5404. }
5405. else
5406. {
5407. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 실패하였습니다."));
5408. item2->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
5409. }
5411. LogManager::instance().ItemLog(this, item2, "SOCKET", item->GetName());
5412. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (METIN)");
5413. break;
5414. }
5416. if (i == ITEM_SOCKET_MAX_NUM)
5417. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("부착할 수 있는 슬롯이 없습니다."));
5418. }
5419. break;
5421. case ITEM_AUTOUSE:
5422. case ITEM_MATERIAL:
5423. case ITEM_SPECIAL:
5424. case ITEM_TOOL:
5425. case ITEM_LOTTERY:
5426. break;
5428. case ITEM_TOTEM:
5429. {
5430. if (!item->IsEquipped())
5431. EquipItem(item);
5432. }
5433. break;
5435. case ITEM_BLEND:
5436. // 새로운 약초들
5437. #ifdef ENABLE_YMIR_AFFECT_FIX
5438. if ((CheckTimeUsed(item) == false)) { return false; }
5439. #endif
5440. sys_log(0,"ITEM_BLEND!!");
5441. if (Blend_Item_find(item->GetVnum()))
5442. {
5443. int affect_type = AFFECT_BLEND;
5444. if (item->GetSocket(0) >= _countof(aApplyInfo))
5445. {
5446. sys_err ("INVALID BLEND ITEM(id : %d, vnum : %d). APPLY TYPE IS %d.", item->GetID(), item->GetVnum(), item->GetSocket(0));
5447. return false;
5448. }
5449. int apply_type = aApplyInfo[item->GetSocket(0)].bPointType;
5450. int apply_value = item->GetSocket(1);
5451. int apply_duration = item->GetSocket(2);
5453. if (FindAffect(affect_type, apply_type))
5454. {
5455. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
5456. }
5457. else
5458. {
5459. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, POINT_RESIST_MAGIC))
5460. {
5461. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
5462. }
5463. else
5464. {
5465. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, false);
5466. item->SetCount(item->GetCount() - 1);
5467. }
5468. }
5469. }
5470. break;
5471. case ITEM_EXTRACT:
5472. {
5473. LPITEM pDestItem = GetItem(DestCell);
5474. if (NULL == pDestItem)
5475. {
5476. return false;
5477. }
5478. switch (item->GetSubType())
5479. {
5480. case EXTRACT_DRAGON_SOUL:
5481. if (pDestItem->IsDragonSoul())
5482. {
5483. return DSManager::instance().PullOut(this, NPOS, pDestItem, item);
5484. }
5485. return false;
5486. case EXTRACT_DRAGON_HEART:
5487. if (pDestItem->IsDragonSoul())
5488. {
5489. return DSManager::instance().ExtractDragonHeart(this, pDestItem, item);
5490. }
5491. return false;
5492. default:
5493. return false;
5494. }
5495. }
5496. break;
5498. case ITEM_NONE:
5499. sys_err("Item type NONE %s", item->GetName());
5500. break;
5502. default:
5503. sys_log(0, "UseItemEx: Unknown type %s %d", item->GetName(), item->GetType());
5504. return false;
5505. }
5507. return true;
5508. }
5510. int g_nPortalLimitTime = 10;
5512. bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell)
5513. {
5514. WORD wCell = Cell.cell;
5515. BYTE window_type = Cell.window_type;
5516. WORD wDestCell = DestCell.cell;
5517. BYTE bDestInven = DestCell.window_type;
5518. LPITEM item;
5520. if (!CanHandleItem())
5521. return false;
5523. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
5524. return false;
5526. sys_log(0, "%s: USE_ITEM %s (inven %d, cell: %d)", GetName(), item->GetName(), window_type, wCell);
5528. if (item->IsExchanging())
5529. return false;
5531. if (!item->CanUsedBy(this))
5532. {
5533. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군직이 맞지않아 이 아이템을 사용할 수 없습니다."));
5534. return false;
5535. }
5537. if (IsStun())
5538. return false;
5540. if (false == FN_check_item_sex(this, item))
5541. {
5542. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 사용할 수 없습니다."));
5543. return false;
5544. }
5546. //PREVENT_TRADE_WINDOW
5547. if (IS_SUMMON_ITEM(item->GetVnum()))
5548. {
5549. if (false == IS_SUMMONABLE_ZONE(GetMapIndex()))
5550. {
5551. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용할수 없습니다."));
5552. return false;
5553. }
5555. // 경혼반지 사용지 상대방이 SUMMONABLE_ZONE에 있는가는 WarpToPC()에서 체크
5557. //삼거리 관려 맵에서는 귀환부를 막아버린다.
5558. if (CThreeWayWar::instance().IsThreeWayWarMapIndex(GetMapIndex()))
5559. {
5560. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("삼거리 전투 참가중에는 귀환부,귀환기억부를 사용할수 없습니다."));
5561. return false;
5562. }
5563. int iPulse = thecore_pulse();
5565. //창고 연후 체크
5566. if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
5567. {
5568. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고를 연후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
5570. if (test_server)
5571. ChatPacket(CHAT_TYPE_INFO, "[TestOnly]Pulse %d LoadTime %d PASS %d", iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
5572. return false;
5573. }
5575. //거래관련 창 체크
5576. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
5577. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner())
5578. {
5579. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 귀환부,귀환기억부 를 사용할수 없습니다."));
5580. return false;
5581. }
5582. #else
5583. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen())
5584. {
5585. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 귀환부,귀환기억부 를 사용할수 없습니다."));
5586. return false;
5587. }
5588. #endif
5590. //PREVENT_REFINE_HACK
5591. //개량후 시간체크
5592. {
5593. if (iPulse - GetRefineTime() < PASSES_PER_SEC(g_nPortalLimitTime))
5594. {
5595. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 개량후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
5596. return false;
5597. }
5598. }
5599. //END_PREVENT_REFINE_HACK
5602. //PREVENT_ITEM_COPY
5603. {
5604. if (iPulse - GetMyShopTime() < PASSES_PER_SEC(g_nPortalLimitTime))
5605. {
5606. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인상점 사용후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
5607. return false;
5608. }
5610. }
5611. //END_PREVENT_ITEM_COPY
5614. //귀환부 거리체크
5615. if (item->GetVnum() != 70302)
5616. {
5617. PIXEL_POSITION posWarp;
5619. int x = 0;
5620. int y = 0;
5622. double nDist = 0;
5623. const double nDistant = 5000.0;
5624. //귀환기억부
5625. if (item->GetVnum() == 22010)
5626. {
5627. x = item->GetSocket(0) - GetX();
5628. y = item->GetSocket(1) - GetY();
5629. }
5630. //귀환부
5631. else if (item->GetVnum() == 22000)
5632. {
5633. SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp);
5635. if (item->GetSocket(0) == 0)
5636. {
5637. x = posWarp.x - GetX();
5638. y = posWarp.y - GetY();
5639. }
5640. else
5641. {
5642. x = item->GetSocket(0) - GetX();
5643. y = item->GetSocket(1) - GetY();
5644. }
5645. }
5647. nDist = sqrt(pow((float)x,2) + pow((float)y,2));
5649. if (nDistant > nDist)
5650. {
5651. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이동 되어질 위치와 너무 가까워 귀환부를 사용할수 없습니다."));
5652. if (test_server)
5653. ChatPacket(CHAT_TYPE_INFO, "PossibleDistant %f nNowDist %f", nDistant,nDist);
5654. return false;
5655. }
5656. }
5658. //PREVENT_PORTAL_AFTER_EXCHANGE
5659. //교환 후 시간체크
5660. if (iPulse - GetExchangeTime() < PASSES_PER_SEC(g_nPortalLimitTime))
5661. {
5662. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에는 귀환부,귀환기억부등을 사용할 수 없습니다."), g_nPortalLimitTime);
5663. return false;
5664. }
5665. //END_PREVENT_PORTAL_AFTER_EXCHANGE
5667. }
5669. //보따리 비단 사용시 거래창 제한 체크
5670. if (item->GetVnum() == 50200 | item->GetVnum() == 71049)
5671. {
5672. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
5673. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner())
5674. {
5675. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 보따리,비단보따리를 사용할수 없습니다."));
5676. return false;
5677. }
5678. #else
5679. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen())
5680. {
5681. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 보따리,비단보따리를 사용할수 없습니다."));
5682. return false;
5683. }
5684. #endif
5686. }
5687. //END_PREVENT_TRADE_WINDOW
5689. if (IS_SET(item->GetFlag(), ITEM_FLAG_LOG)) // 사용 로그를 남기는 아이템 처리
5690. {
5691. DWORD vid = item->GetVID();
5692. DWORD oldCount = item->GetCount();
5693. DWORD vnum = item->GetVnum();
5695. char hint[ITEM_NAME_MAX_LEN + 32 + 1];
5696. int len = snprintf(hint, sizeof(hint) - 32, "%s", item->GetName());
5698. if (len < 0 || len >= (int) sizeof(hint) - 32)
5699. len = (sizeof(hint) - 32) - 1;
5701. bool ret = UseItemEx(item, DestCell);
5703. if (NULL == ITEM_MANAGER::instance().FindByVID(vid)) // UseItemEx에서 아이템이 삭제 되었다. 삭제 로그를 남김
5704. {
5705. LogManager::instance().ItemLog(this, vid, vnum, "REMOVE", hint);
5706. }
5707. else if (oldCount != item->GetCount())
5708. {
5709. snprintf(hint + len, sizeof(hint) - len, " %u", oldCount - 1);
5710. LogManager::instance().ItemLog(this, vid, vnum, "USE_ITEM", hint);
5711. }
5712. return (ret);
5713. }
5714. else
5715. return UseItemEx(item, DestCell);
5716. }
5718. bool CHARACTER::DropItem(TItemPos Cell, BYTE bCount)
5719. {
5720. LPITEM item = NULL;
5722. if (!CanHandleItem())
5723. {
5724. if (NULL != DragonSoul_RefineWindow_GetOpener())
5725. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
5726. return false;
5727. }
5729. if (IsDead())
5730. return false;
5732. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
5733. return false;
5735. if (item->IsExchanging())
5736. return false;
5738. if (true == item->isLocked())
5739. return false;
5741. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
5742. return false;
5744. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP | ITEM_ANTIFLAG_GIVE))
5745. {
5746. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("버릴 수 없는 아이템입니다."));
5747. return false;
5748. }
5750. if (bCount == 0 || bCount > item->GetCount())
5751. bCount = item->GetCount();
5753. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255); // Quickslot 에서 지움
5755. LPITEM pkItemToDrop;
5757. if (bCount == item->GetCount())
5758. {
5759. item->RemoveFromCharacter();
5760. pkItemToDrop = item;
5761. }
5762. else
5763. {
5764. if (bCount == 0)
5765. {
5766. if (test_server)
5767. sys_log(0, "[DROP_ITEM] drop item count == 0");
5768. return false;
5769. }
5771. // check non-split items for china
5772. //if (LC_IsNewCIBN())
5773. // if (item->GetVnum() == 71095 || item->GetVnum() == 71050 || item->GetVnum() == 70038)
5774. // return false;
5776. item->SetCount(item->GetCount() - bCount);
5777. ITEM_MANAGER::instance().FlushDelayedSave(item);
5779. pkItemToDrop = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), bCount);
5781. // copy item socket -- by mhh
5782. FN_copy_item_socket(pkItemToDrop, item);
5784. char szBuf[51 + 1];
5785. snprintf(szBuf, sizeof(szBuf), "%u %u", pkItemToDrop->GetID(), pkItemToDrop->GetCount());
5786. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
5787. }
5789. PIXEL_POSITION pxPos = GetXYZ();
5791. if (pkItemToDrop->AddToGround(GetMapIndex(), pxPos))
5792. {
5793. // 한국에는 아이템을 버리고 복구해달라는 진상유저들이 많아서
5794. // 아이템을 바닥에 버릴 시 속성로그를 남긴다.
5795. if (LC_IsYMIR())
5796. item->AttrLog();
5798. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("떨어진 아이템은 3분 후 사라집니다."));
5799. pkItemToDrop->StartDestroyEvent(6);
5801. ITEM_MANAGER::instance().FlushDelayedSave(pkItemToDrop);
5803. char szHint[32 + 1];
5804. snprintf(szHint, sizeof(szHint), "%s %u %u", pkItemToDrop->GetName(), pkItemToDrop->GetCount(), pkItemToDrop->GetOriginalVnum());
5805. LogManager::instance().ItemLog(this, pkItemToDrop, "DROP", szHint);
5806. //Motion(MOTION_PICKUP);
5807. }
5809. return true;
5810. }
5812. bool CHARACTER::DestroyItem(TItemPos Cell)
5813. {
5814. LPITEM item = NULL;
5815. if (!CanHandleItem())
5816. {
5817. if (NULL != DragonSoul_RefineWindow_GetOpener())
5818. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°*E*A￠A≫ ¿￢ ≫oAA¿¡¼*´A ¾ÆAIAUA≫ ¿A±æ ¼o ¾ø½A´I´U."));
5819. return false;
5820. }
5821. if (IsDead())
5822. return false;
5823. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
5824. return false;
5825. if (item->IsExchanging())
5826. return false;
5827. if (true == item->isLocked())
5828. return false;
5829. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
5830. return false;
5831. if (item->GetCount() <= 0)
5832. return false;
5833. #ifdef NEW_PET_SYSTEM
5834. if (GetNewPetSystem()->IsActivePet())
5835. {
5836. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Mai intai trimite pet-ul"));
5837. return false;
5838. }
5839. #endif
5840. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255);
5841. ITEM_MANAGER::instance().RemoveItem(item);
5842. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ai distrus %s !"), item->GetName());
5843. return true;
5844. }
5846. bool CHARACTER::DropGold(int gold)
5847. {
5848. return false;
5849. }
5851. bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, BYTE count)
5852. {
5853. LPITEM item = NULL;
5855. if (!IsValidItemPosition(Cell))
5856. return false;
5858. if (!(item = GetItem(Cell)))
5859. return false;
5861. if (item->IsExchanging())
5862. return false;
5864. if (item->GetCount() < count)
5865. return false;
5867. if (INVENTORY == Cell.window_type && Cell.cell >= INVENTORY_MAX_NUM && IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
5868. return false;
5870. if (true == item->isLocked())
5871. return false;
5873. if (!IsValidItemPosition(DestCell))
5874. {
5875. return false;
5876. }
5878. if (!CanHandleItem())
5879. {
5880. if (NULL != DragonSoul_RefineWindow_GetOpener())
5881. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
5882. return false;
5883. }
5885. // 기획자의 요청으로 벨트 인벤토리에는 특정 타입의 아이템만 넣을 수 있다.
5886. if (DestCell.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(item))
5887. {
5888. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 벨트 인벤토리로 옮길 수 없습니다."));
5889. return false;
5890. }
5892. // 이미 착용중인 아이템을 다른 곳으로 옮기는 경우, '장책 해제' 가능한 지 확인하고 옮김
5893. if (Cell.IsEquipPosition())
5894. {
5895. if (!CanUnequipNow(item))
5896. return false;
5898. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
5899. int iWearCell = item->FindEquipCell(this);
5900. if (iWearCell == WEAR_WEAPON)
5901. {
5902. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
5903. if (costumeWeapon && !UnequipItem(costumeWeapon))
5904. {
5905. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
5906. return false;
5907. }
5909. if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
5910. return UnequipItem(item);
5911. }
5912. #endif
5913. }
5915. if (DestCell.IsEquipPosition())
5916. {
5917. if (GetItem(DestCell)) // 장비일 경우 한 곳만 검사해도 된다.
5918. {
5919. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 장비를 착용하고 있습니다."));
5921. return false;
5922. }
5924. EquipItem(item, DestCell.cell - INVENTORY_MAX_NUM);
5925. }
5926. else
5927. {
5928. if (item->IsDragonSoul())
5929. {
5930. if (item->IsEquipped())
5931. {
5932. return DSManager::instance().PullOut(this, DestCell, item);
5933. }
5934. else
5935. {
5936. if (DestCell.window_type != DRAGON_SOUL_INVENTORY)
5937. {
5938. return false;
5939. }
5941. if (!DSManager::instance().IsValidCellForThisItem(item, DestCell))
5942. return false;
5943. }
5944. }
5945. // 용혼석이 아닌 아이템은 용혼석 인벤에 들어갈 수 없다.
5946. else if (DRAGON_SOUL_INVENTORY == DestCell.window_type)
5947. return false;
5949. LPITEM item2;
5951. if ((item2 = GetItem(DestCell)) && item != item2 && item2->IsStackable() &&
5952. !IS_SET(item2->GetAntiFlag(), ITEM_ANTIFLAG_STACK) &&
5953. item2->GetVnum() == item->GetVnum()) // 합칠 수 있는 아이템의 경우
5954. {
5955. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
5956. if (item2->GetSocket(i) != item->GetSocket(i))
5957. return false;
5959. if (count == 0)
5960. count = item->GetCount();
5962. 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,
5963. DestCell.window_type, DestCell.cell, count);
5965. count = MIN(200 - item2->GetCount(), count);
5967. item->SetCount(item->GetCount() - count);
5968. item2->SetCount(item2->GetCount() + count);
5969. return true;
5970. }
5972. if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
5973. return false;
5975. if (count == 0 || count >= item->GetCount() || !item->IsStackable() || IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
5976. {
5977. 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,
5978. DestCell.window_type, DestCell.cell, count);
5980. item->RemoveFromCharacter();
5981. SetItem(DestCell, item);
5983. if (INVENTORY == Cell.window_type && INVENTORY == DestCell.window_type)
5984. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, DestCell.cell);
5985. }
5986. else if (count < item->GetCount())
5987. {
5988. //check non-split items
5989. //if (LC_IsNewCIBN())
5990. //{
5991. // if (item->GetVnum() == 71095 || item->GetVnum() == 71050 || item->GetVnum() == 70038)
5992. // {
5993. // return false;
5994. // }
5995. //}
5997. 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,
5998. DestCell.window_type, DestCell.cell, count);
6000. item->SetCount(item->GetCount() - count);
6001. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), count);
6003. // copy socket -- by mhh
6004. FN_copy_item_socket(item2, item);
6006. item2->AddToCharacter(this, DestCell);
6008. char szBuf[51+1];
6009. snprintf(szBuf, sizeof(szBuf), "%u %u %u %u ", item2->GetID(), item2->GetCount(), item->GetCount(), item->GetCount() + item2->GetCount());
6010. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
6011. }
6012. }
6014. return true;
6015. }
6017. namespace NPartyPickupDistribute
6018. {
6019. struct FFindOwnership
6020. {
6021. LPITEM item;
6022. LPCHARACTER owner;
6024. FFindOwnership(LPITEM item)
6025. : item(item), owner(NULL)
6026. {
6027. }
6029. void operator () (LPCHARACTER ch)
6030. {
6031. if (item->IsOwnership(ch))
6032. owner = ch;
6033. }
6034. };
6036. struct FCountNearMember
6037. {
6038. int total;
6039. int x, y;
6041. FCountNearMember(LPCHARACTER center )
6042. : total(0), x(center->GetX()), y(center->GetY())
6043. {
6044. }
6046. void operator () (LPCHARACTER ch)
6047. {
6048. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
6049. total += 1;
6050. }
6051. };
6053. struct FMoneyDistributor
6054. {
6055. int total;
6056. LPCHARACTER c;
6057. int x, y;
6058. int iMoney;
6060. FMoneyDistributor(LPCHARACTER center, int iMoney)
6061. : total(0), c(center), x(center->GetX()), y(center->GetY()), iMoney(iMoney)
6062. {
6063. }
6065. void operator ()(LPCHARACTER ch)
6066. {
6067. if (ch!=c)
6068. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
6069. {
6070. ch->PointChange(POINT_GOLD, iMoney, true);
6072. if (iMoney > 1000) // 천원 이상만 기록한다.
6073. LogManager::instance().CharLog(ch, iMoney, "GET_GOLD", "");
6074. }
6075. }
6076. };
6077. }
6079. void CHARACTER::GiveGold(long long iAmount)
6080. {
6081. if (iAmount <= 0)
6082. return;
6084. sys_log(0, "GIVE_GOLD: %s %lld", GetName(), iAmount);
6086. if (GetParty())
6087. {
6088. LPPARTY pParty = GetParty();
6090. long long dwTotal = iAmount;
6091. long long dwMyAmount = dwTotal;
6093. NPartyPickupDistribute::FCountNearMember funcCountNearMember(this);
6094. pParty->ForEachOnlineMember(funcCountNearMember);
6096. if (funcCountNearMember.total > 1)
6097. {
6098. DWORD dwShare = dwTotal / funcCountNearMember.total;
6099. dwMyAmount -= dwShare * (funcCountNearMember.total - 1);
6101. NPartyPickupDistribute::FMoneyDistributor funcMoneyDist(this, dwShare);
6103. pParty->ForEachOnlineMember(funcMoneyDist);
6104. }
6106. PointChange(POINT_GOLD, dwMyAmount, true);
6108. if (dwMyAmount > 1000) // 천원 이상만 기록한다.
6109. LogManager::instance().CharLog(this, dwMyAmount, "GET_GOLD", "");
6110. }
6111. else
6112. {
6113. PointChange(POINT_GOLD, iAmount, true);
6115. // 브라질에 돈이 없어진다는 버그가 있는데,
6116. // 가능한 시나리오 중에 하나는,
6117. // 메크로나, 핵을 써서 1000원 이하의 돈을 계속 버려 골드를 0으로 만들고,
6118. // 돈이 없어졌다고 복구 신청하는 것일 수도 있다.
6119. // 따라서 그런 경우를 잡기 위해 낮은 수치의 골드에 대해서도 로그를 남김.
6120. if (LC_IsBrazil() == true)
6121. {
6122. if (iAmount >= 213)
6123. LogManager::instance().CharLog(this, iAmount, "GET_GOLD", "");
6124. }
6125. else
6126. {
6127. if (iAmount > 1000) // 천원 이상만 기록한다.
6128. LogManager::instance().CharLog(this, iAmount, "GET_GOLD", "");
6129. }
6130. }
6131. }
6133. bool CHARACTER::PickupItem(DWORD dwVID)
6134. {
6135. LPITEM item = ITEM_MANAGER::instance().FindByVID(dwVID);
6137. if (IsObserverMode())
6138. return false;
6140. if (!item || !item->GetSectree())
6141. return false;
6143. if (item->DistanceValid(this))
6144. {
6145. if (item->IsOwnership(this))
6146. {
6147. // 만약 주으려 하는 아이템이 엘크라면
6148. if (item->GetType() == ITEM_ELK)
6149. {
6150. GiveGold(item->GetCount());
6151. item->RemoveFromGround();
6153. M2_DESTROY_ITEM(item);
6155. Save();
6156. }
6157. // 평범한 아이템이라면
6158. else
6159. {
6160. if (item->IsStackable() && !IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
6161. {
6162. BYTE bCount = item->GetCount();
6164. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
6165. {
6166. LPITEM item2 = GetInventoryItem(i);
6168. if (!item2)
6169. continue;
6171. if (item2->GetVnum() == item->GetVnum())
6172. {
6173. int j;
6175. for (j = 0; j < ITEM_SOCKET_MAX_NUM; ++j)
6176. if (item2->GetSocket(j) != item->GetSocket(j))
6177. break;
6179. if (j != ITEM_SOCKET_MAX_NUM)
6180. continue;
6182. BYTE bCount2 = MIN(200 - item2->GetCount(), bCount);
6183. bCount -= bCount2;
6185. item2->SetCount(item2->GetCount() + bCount2);
6187. if (bCount == 0)
6188. {
6189. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item2->GetName());
6190. M2_DESTROY_ITEM(item);
6191. if (item2->GetType() == ITEM_QUEST)
6192. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item2);
6193. return true;
6194. }
6195. }
6196. }
6198. item->SetCount(bCount);
6199. }
6201. int iEmptyCell;
6202. if (item->IsDragonSoul())
6203. {
6204. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
6205. {
6206. sys_log(0, "No empty ds inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
6207. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
6208. return false;
6209. }
6210. }
6211. else
6212. {
6213. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
6214. {
6215. sys_log(0, "No empty inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
6216. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
6217. return false;
6218. }
6219. }
6221. item->RemoveFromGround();
6223. if (item->IsDragonSoul())
6224. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
6225. else
6226. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
6228. char szHint[32+1];
6229. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
6230. LogManager::instance().ItemLog(this, item, "GET", szHint);
6231. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
6233. if (item->GetType() == ITEM_QUEST)
6234. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item);
6235. }
6237. //Motion(MOTION_PICKUP);
6238. return true;
6239. }
6240. else if (!IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_DROP) && GetParty())
6241. {
6242. // 다른 파티원 소유권 아이템을 주으려고 한다면
6243. NPartyPickupDistribute::FFindOwnership funcFindOwnership(item);
6245. GetParty()->ForEachOnlineMember(funcFindOwnership);
6247. LPCHARACTER owner = funcFindOwnership.owner;
6249. int iEmptyCell;
6251. if (item->IsDragonSoul())
6252. {
6253. if (!(owner && (iEmptyCell = owner->GetEmptyDragonSoulInventory(item)) != -1))
6254. {
6255. owner = this;
6257. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
6258. {
6259. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
6260. return false;
6261. }
6262. }
6263. }
6264. else
6265. {
6266. if (!(owner && (iEmptyCell = owner->GetEmptyInventory(item->GetSize())) != -1))
6267. {
6268. owner = this;
6270. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
6271. {
6272. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
6273. return false;
6274. }
6275. }
6276. }
6278. item->RemoveFromGround();
6280. if (item->IsDragonSoul())
6281. item->AddToCharacter(owner, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
6282. else
6283. item->AddToCharacter(owner, TItemPos(INVENTORY, iEmptyCell));
6285. char szHint[32+1];
6286. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
6287. LogManager::instance().ItemLog(owner, item, "GET", szHint);
6289. if (owner == this)
6290. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
6291. else
6292. {
6293. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s 님으로부터 %s"), GetName(), item->GetName());
6294. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 전달: %s 님에게 %s"), owner->GetName(), item->GetName());
6295. }
6297. if (item->GetType() == ITEM_QUEST)
6298. quest::CQuestManager::instance().PickupItem (owner->GetPlayerID(), item);
6300. return true;
6301. }
6302. }
6304. return false;
6305. }
6307. bool CHARACTER::SwapItem(BYTE bCell, BYTE bDestCell)
6308. {
6309. if (!CanHandleItem())
6310. return false;
6312. TItemPos srcCell(INVENTORY, bCell), destCell(INVENTORY, bDestCell);
6314. // 올바른 Cell 인지 검사
6315. // 용혼석은 Swap할 수 없으므로, 여기서 걸림.
6316. //if (bCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM || bDestCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM)
6317. if (srcCell.IsDragonSoulEquipPosition() || destCell.IsDragonSoulEquipPosition())
6318. return false;
6320. // 같은 CELL 인지 검사
6321. if (bCell == bDestCell)
6322. return false;
6324. // 둘 다 장비창 위치면 Swap 할 수 없다.
6325. if (srcCell.IsEquipPosition() && destCell.IsEquipPosition())
6326. return false;
6328. LPITEM item1, item2;
6330. // item2가 장비창에 있는 것이 되도록.
6331. if (srcCell.IsEquipPosition())
6332. {
6333. item1 = GetInventoryItem(bDestCell);
6334. item2 = GetInventoryItem(bCell);
6335. }
6336. else
6337. {
6338. item1 = GetInventoryItem(bCell);
6339. item2 = GetInventoryItem(bDestCell);
6340. }
6342. if (!item1 || !item2)
6343. return false;
6345. if (item1 == item2)
6346. {
6347. sys_log(0, "[WARNING][WARNING][HACK USER!] : %s %d %d", m_stName.c_str(), bCell, bDestCell);
6348. return false;
6349. }
6351. // item2가 bCell위치에 들어갈 수 있는지 확인한다.
6352. if (!IsEmptyItemGrid(TItemPos (INVENTORY, item1->GetCell()), item2->GetSize(), item1->GetCell()))
6353. return false;
6355. // 바꿀 아이템이 장비창에 있으면
6356. if (TItemPos(EQUIPMENT, item2->GetCell()).IsEquipPosition())
6357. {
6358. BYTE bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;
6359. BYTE bInvenCell = item1->GetCell();
6361. // 착용중인 아이템을 벗을 수 있고, 착용 예정 아이템이 착용 가능한 상태여야만 진행
6362. if (item2->IsDragonSoul() || item2->GetType() == ITEM_BELT) // @fixme117
6363. {
6364. if (false == CanUnequipNow(item2) || false == CanEquipNow(item1))
6365. return false;
6366. }
6368. if (bEquipCell != item1->FindEquipCell(this)) // 같은 위치일때만 허용
6369. return false;
6371. item2->RemoveFromCharacter();
6373. if (item1->EquipTo(this, bEquipCell))
6374. item2->AddToCharacter(this, TItemPos(INVENTORY, bInvenCell));
6375. else
6376. sys_err("SwapItem cannot equip %s! item1 %s", item2->GetName(), item1->GetName());
6377. }
6378. else
6379. {
6380. BYTE bCell1 = item1->GetCell();
6381. BYTE bCell2 = item2->GetCell();
6383. item1->RemoveFromCharacter();
6384. item2->RemoveFromCharacter();
6386. item1->AddToCharacter(this, TItemPos(INVENTORY, bCell2));
6387. item2->AddToCharacter(this, TItemPos(INVENTORY, bCell1));
6388. }
6390. return true;
6391. }
6393. bool CHARACTER::UnequipItem(LPITEM item)
6394. {
6395. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
6396. int iWearCell = item->FindEquipCell(this);
6397. if (iWearCell == WEAR_WEAPON)
6398. {
6399. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
6400. if (costumeWeapon && !UnequipItem(costumeWeapon))
6401. {
6402. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
6403. return false;
6404. }
6405. }
6406. #endif
6408. if (false == CanUnequipNow(item))
6409. return false;
6411. int pos;
6412. if (item->IsDragonSoul())
6413. pos = GetEmptyDragonSoulInventory(item);
6414. else
6415. pos = GetEmptyInventory(item->GetSize());
6417. // HARD CODING
6418. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
6419. ShowAlignment(true);
6421. item->RemoveFromCharacter();
6422. if (item->IsDragonSoul())
6423. {
6424. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, pos));
6425. }
6426. else
6427. item->AddToCharacter(this, TItemPos(INVENTORY, pos));
6429. CheckMaximumPoints();
6431. return true;
6432. }
6434. //
6435. // @version 05/07/05 Bang2ni - Skill 사용후 1.5 초 이내에 장비 착용 금지
6436. //
6437. bool CHARACTER::EquipItem(LPITEM item, int iCandidateCell)
6438. {
6439. LPITEM belt1,belt2;
6440. if (item->IsExchanging())
6441. return false;
6443. if (false == item->IsEquipable())
6444. return false;
6446. if (false == CanEquipNow(item))
6447. return false;
6449. int iWearCell = item->FindEquipCell(this, iCandidateCell);
6450. TItemPos srcCell(INVENTORY, item->GetCell()), destCell(INVENTORY, INVENTORY_MAX_NUM + iWearCell);
6451. if (iWearCell < 0)
6452. return false;
6454. // 무언가를 탄 상태에서 턱시도 입기 금지
6455. if (iWearCell == WEAR_BODY && IsRiding() && (item->GetVnum() >= 11901 && item->GetVnum() <= 11904))
6456. {
6457. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말을 탄 상태에서 예복을 입을 수 없습니다."));
6458. return false;
6459. }
6461. if (iWearCell != WEAR_ARROW && IsPolymorphed())
6462. {
6463. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 착용중인 장비를 변경할 수 없습니다."));
6464. return false;
6465. }
6466. //fix dnd costum de nunta
6467. if (GetWear(WEAR_BODY) && GetWear(WEAR_BODY)->GetVnum() >= 11901 && GetWear(WEAR_BODY)->GetVnum() <= 11904 &&
6468. item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_BODY)
6469. {
6470. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nu poti purta un costum atat timp cat ai echipat un obiect de nunta."));
6471. return false;
6472. }
6473. //fix dnd costum nunta end
6474. if (GetWear(WEAR_COSTUME_BODY) && item->GetVnum() >= 11901 && item->GetVnum() <= 11904)
6475. {
6476. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nu poti purta un costum atat timp cat ai echipat un obiect de nunta."));
6477. return false;
6478. }
6480. if (FN_check_item_sex(this, item) == false)
6481. {
6482. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 사용할 수 없습니다."));
6483. return false;
6484. }
6486. //신규 탈것 사용시 기존 말 사용여부 체크
6487. if(item->IsRideItem() && IsRiding())
6488. {
6489. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 탈것을 이용중입니다."));
6490. return false;
6491. }
6493. // 화살 이외에는 마지막 공격 시간 또는 스킬 사용 1.5 후에 장비 교체가 가능
6494. DWORD dwCurTime = get_dword_time();
6496. if (iWearCell != WEAR_ARROW
6497. && (dwCurTime - GetLastAttackTime() <= 1500 || dwCurTime - m_dwLastSkillTime <= 1500))
6498. {
6499. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("가만히 있을 때만 착용할 수 있습니다."));
6500. return false;
6501. }
6502. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
6503. if (iWearCell == WEAR_WEAPON)
6504. {
6505. if (item->GetType() == ITEM_WEAPON)
6506. {
6507. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
6508. if (costumeWeapon && costumeWeapon->GetValue(3) != item->GetSubType() && !UnequipItem(costumeWeapon))
6509. {
6510. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
6511. return false;
6512. }
6513. }
6514. else //fishrod/pickaxe
6515. {
6516. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
6517. if (costumeWeapon && !UnequipItem(costumeWeapon))
6518. {
6519. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
6520. return false;
6521. }
6522. }
6523. }
6524. else if (iWearCell == WEAR_COSTUME_WEAPON)
6525. {
6526. if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_WEAPON)
6527. {
6528. LPITEM pkWeapon = GetWear(WEAR_WEAPON);
6529. if (!pkWeapon || pkWeapon->GetType() != ITEM_WEAPON || item->GetValue(3) != pkWeapon->GetSubType())
6530. {
6531. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot equip the costume weapon. Wrong equipped weapon."));
6532. return false;
6533. }
6534. }
6535. }
6536. #endif
6538. // 용혼석 특수 처리
6539. if (item->IsDragonSoul())
6540. {
6541. // 같은 타입의 용혼석이 이미 들어가 있다면 착용할 수 없다.
6542. // 용혼석은 swap을 지원하면 안됨.
6543. if(GetInventoryItem(INVENTORY_MAX_NUM + iWearCell))
6544. {
6545. ChatPacket(CHAT_TYPE_INFO, "이미 같은 종류의 용혼석을 착용하고 있습니다.");
6546. return false;
6547. }
6549. if (!item->EquipTo(this, iWearCell))
6550. {
6551. return false;
6552. }
6553. }
6554. // 용혼석이 아님.
6555. else
6556. {
6557. // 착용할 곳에 아이템이 있다면,
6558. if (GetWear(iWearCell) && !IS_SET(GetWear(iWearCell)->GetFlag(), ITEM_FLAG_IRREMOVABLE))
6559. {
6560. // 이 아이템은 한번 박히면 변경 불가. swap 역시 완전 불가
6561. if (item->GetWearFlag() == WEARABLE_ABILITY)
6562. return false;
6563. if (srcCell.IsEquipPosition())
6564. {
6565. belt1 = GetInventoryItem(INVENTORY_MAX_NUM + iWearCell);
6566. belt2 = GetInventoryItem(item->GetCell());
6567. }
6568. else
6569. {
6570. belt1 = GetInventoryItem(item->GetCell());
6571. belt2 = GetInventoryItem(INVENTORY_MAX_NUM + iWearCell);
6572. }
6574. if ((ITEM_BELT == belt2->GetType()) && (CBeltInventoryHelper::IsExistItemInBeltInventory(this) == true))
6575. {
6576. //ChatPacket(CHAT_TYPE_INFO, LC_TEXT("?§Ζ® ?Ξ?￥Εδ?®?? ?Ζ?ΜΕ??Μ Α??ηΗΟ?ι ΗΨΑ|Η? ?φ ?ψ½??Ο?Ω."));
6577. return false;
6578. }
6579. if (false == SwapItem(item->GetCell(), INVENTORY_MAX_NUM + iWearCell))
6580. {
6581. return false;
6582. }
6583. }
6584. else
6585. {
6586. BYTE bOldCell = item->GetCell();
6588. if (item->EquipTo(this, iWearCell))
6589. {
6590. SyncQuickslot(QUICKSLOT_TYPE_ITEM, bOldCell, iWearCell);
6591. }
6592. }
6593. }
6595. if (true == item->IsEquipped())
6596. {
6597. // 아이템 최초 사용 이후부터는 사용하지 않아도 시간이 차감되는 방식 처리.
6598. if (-1 != item->GetProto()->cLimitRealTimeFirstUseIndex)
6599. {
6600. // 한 번이라도 사용한 아이템인지 여부는 Socket1을 보고 판단한다. (Socket1에 사용횟수 기록)
6601. if (0 == item->GetSocket(1))
6602. {
6603. // 사용가능시간은 Default 값으로 Limit Value 값을 사용하되, Socket0에 값이 있으면 그 값을 사용하도록 한다. (단위는 초)
6604. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[item->GetProto()->cLimitRealTimeFirstUseIndex].lValue;
6606. if (0 == duration)
6607. duration = 60 * 60 * 24 * 7;
6609. item->SetSocket(0, time(0) + duration);
6610. item->StartRealTimeExpireEvent();
6611. }
6613. item->SetSocket(1, item->GetSocket(1) + 1);
6614. }
6616. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
6617. ShowAlignment(false);
6619. const DWORD& dwVnum = item->GetVnum();
6621. // 라마단 이벤트 초승달의 반지(71135) 착용시 이펙트 발동
6622. if (true == CItemVnumHelper::IsRamadanMoonRing(dwVnum))
6623. {
6624. this->EffectPacket(SE_EQUIP_RAMADAN_RING);
6625. }
6626. // 할로윈 사탕(71136) 착용시 이펙트 발동
6627. else if (true == CItemVnumHelper::IsHalloweenCandy(dwVnum))
6628. {
6629. this->EffectPacket(SE_EQUIP_HALLOWEEN_CANDY);
6630. }
6631. // 행복의 반지(71143) 착용시 이펙트 발동
6632. else if (true == CItemVnumHelper::IsHappinessRing(dwVnum))
6633. {
6634. this->EffectPacket(SE_EQUIP_HAPPINESS_RING);
6635. }
6636. // 사랑의 팬던트(71145) 착용시 이펙트 발동
6637. else if (true == CItemVnumHelper::IsLovePendant(dwVnum))
6638. {
6639. this->EffectPacket(SE_EQUIP_LOVE_PENDANT);
6640. }
6641. // ITEM_UNIQUE의 경우, SpecialItemGroup에 정의되어 있고, (item->GetSIGVnum() != NULL)
6642. //
6643. else if (ITEM_UNIQUE == item->GetType() && 0 != item->GetSIGVnum())
6644. {
6645. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(item->GetSIGVnum());
6646. if (NULL != pGroup)
6647. {
6648. const CSpecialAttrGroup* pAttrGroup = ITEM_MANAGER::instance().GetSpecialAttrGroup(pGroup->GetAttrVnum(item->GetVnum()));
6649. if (NULL != pAttrGroup)
6650. {
6651. const std::string& std = pAttrGroup->m_stEffectFileName;
6652. SpecificEffectPacket(std.c_str());
6653. }
6654. }
6655. }
6656. #ifdef __SASH_SYSTEM__
6657. else if ((item->GetType() == ITEM_COSTUME) && (item->GetSubType() == COSTUME_SASH))
6658. this->EffectPacket(SE_EFFECT_SASH_EQUIP);
6659. #endif
6661. if (
6662. (ITEM_UNIQUE == item->GetType() && UNIQUE_SPECIAL_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE))
6663. || (ITEM_UNIQUE == item->GetType() && UNIQUE_SPECIAL_MOUNT_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE)))
6664. {
6665. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
6666. }
6667. if (COSTUME_MOUNT == item->GetSubType())
6668. {
6669. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
6670. }
6671. }
6673. return true;
6674. }
6676. void CHARACTER::BuffOnAttr_AddBuffsFromItem(LPITEM pItem)
6677. {
6678. for (int i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
6679. {
6680. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
6681. if (it != m_map_buff_on_attrs.end())
6682. {
6683. it->second->AddBuffFromItem(pItem);
6684. }
6685. }
6686. }
6688. void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem)
6689. {
6690. for (int i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
6691. {
6692. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
6693. if (it != m_map_buff_on_attrs.end())
6694. {
6695. it->second->RemoveBuffFromItem(pItem);
6696. }
6697. }
6698. }
6700. void CHARACTER::BuffOnAttr_ClearAll()
6701. {
6702. for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
6703. {
6704. CBuffOnAttributes* pBuff = it->second;
6705. if (pBuff)
6706. {
6707. pBuff->Initialize();
6708. }
6709. }
6710. }
6712. void CHARACTER::BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue)
6713. {
6714. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(bType);
6716. if (0 == bNewValue)
6717. {
6718. if (m_map_buff_on_attrs.end() == it)
6719. return;
6720. else
6721. it->second->Off();
6722. }
6723. else if(0 == bOldValue)
6724. {
6725. CBuffOnAttributes* pBuff;
6726. if (m_map_buff_on_attrs.end() == it)
6727. {
6728. switch (bType)
6729. {
6730. case POINT_ENERGY:
6731. {
6732. static BYTE abSlot[] = { WEAR_BODY, WEAR_HEAD, WEAR_FOOTS, WEAR_WRIST, WEAR_WEAPON, WEAR_NECK, WEAR_EAR, WEAR_SHIELD };
6733. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
6734. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
6735. }
6736. break;
6737. case POINT_COSTUME_ATTR_BONUS:
6738. {
6739. static BYTE abSlot[] = {WEAR_COSTUME_BODY, WEAR_COSTUME_HAIR,
6740. #ifdef __WEAPON_COSTUME_SYSTEM__
6741. WEAR_COSTUME_WEAPON,
6742. #endif
6743. };
6744. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
6745. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
6746. }
6747. break;
6748. default:
6749. break;
6750. }
6751. m_map_buff_on_attrs.insert(TMapBuffOnAttrs::value_type(bType, pBuff));
6753. }
6754. else
6755. pBuff = it->second;
6757. pBuff->On(bNewValue);
6758. }
6759. else
6760. {
6761. if (m_map_buff_on_attrs.end() == it)
6762. return;
6763. else
6764. it->second->ChangeBuffValue(bNewValue);
6765. }
6766. }
6769. LPITEM CHARACTER::FindSpecifyItem(DWORD vnum) const
6770. {
6771. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
6772. if (GetInventoryItem(i) && GetInventoryItem(i)->GetVnum() == vnum)
6773. return GetInventoryItem(i);
6775. return NULL;
6776. }
6778. LPITEM CHARACTER::FindItemByID(DWORD id) const
6779. {
6780. for (int i=0 ; i < INVENTORY_MAX_NUM ; ++i)
6781. {
6782. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
6783. return GetInventoryItem(i);
6784. }
6786. for (int i=BELT_INVENTORY_SLOT_START; i < BELT_INVENTORY_SLOT_END ; ++i)
6787. {
6788. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
6789. return GetInventoryItem(i);
6790. }
6792. return NULL;
6793. }
6795. int CHARACTER::CountSpecifyItem(DWORD vnum) const
6796. {
6797. int count = 0;
6798. LPITEM item;
6800. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
6801. {
6802. item = GetInventoryItem(i);
6803. if (NULL != item && item->GetVnum() == vnum)
6804. {
6805. // 개인 상점에 등록된 물건이면 넘어간다.
6806. if (m_pkMyShop && m_pkMyShop->IsSellingItem(item->GetID()))
6807. {
6808. continue;
6809. }
6810. else
6811. {
6812. count += item->GetCount();
6813. }
6814. }
6815. }
6817. return count;
6818. }
6820. void CHARACTER::RemoveSpecifyItem(DWORD vnum, DWORD count)
6821. {
6822. if (0 == count)
6823. return;
6825. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
6826. {
6827. if (NULL == GetInventoryItem(i))
6828. continue;
6830. if (GetInventoryItem(i)->GetVnum() != vnum)
6831. continue;
6833. //개인 상점에 등록된 물건이면 넘어간다. (개인 상점에서 판매될때 이 부분으로 들어올 경우 문제!)
6834. if(m_pkMyShop)
6835. {
6836. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
6837. if (isItemSelling)
6838. continue;
6839. }
6841. if (vnum >= 80003 && vnum <= 80007)
6842. LogManager::instance().GoldBarLog(GetPlayerID(), GetInventoryItem(i)->GetID(), QUEST, "RemoveSpecifyItem");
6844. if (count >= GetInventoryItem(i)->GetCount())
6845. {
6846. count -= GetInventoryItem(i)->GetCount();
6847. GetInventoryItem(i)->SetCount(0);
6849. if (0 == count)
6850. return;
6851. }
6852. else
6853. {
6854. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
6855. return;
6856. }
6857. }
6859. // 예외처리가 약하다.
6860. if (count)
6861. sys_log(0, "CHARACTER::RemoveSpecifyItem cannot remove enough item vnum %u, still remain %d", vnum, count);
6862. }
6864. int CHARACTER::CountSpecifyTypeItem(BYTE type) const
6865. {
6866. int count = 0;
6868. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
6869. {
6870. LPITEM pItem = GetInventoryItem(i);
6871. if (pItem != NULL && pItem->GetType() == type)
6872. {
6873. count += pItem->GetCount();
6874. }
6875. }
6877. return count;
6878. }
6880. void CHARACTER::RemoveSpecifyTypeItem(BYTE type, DWORD count)
6881. {
6882. if (0 == count)
6883. return;
6885. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
6886. {
6887. if (NULL == GetInventoryItem(i))
6888. continue;
6890. if (GetInventoryItem(i)->GetType() != type)
6891. continue;
6893. //개인 상점에 등록된 물건이면 넘어간다. (개인 상점에서 판매될때 이 부분으로 들어올 경우 문제!)
6894. if(m_pkMyShop)
6895. {
6896. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
6897. if (isItemSelling)
6898. continue;
6899. }
6901. if (count >= GetInventoryItem(i)->GetCount())
6902. {
6903. count -= GetInventoryItem(i)->GetCount();
6904. GetInventoryItem(i)->SetCount(0);
6906. if (0 == count)
6907. return;
6908. }
6909. else
6910. {
6911. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
6912. return;
6913. }
6914. }
6915. }
6917. void CHARACTER::AutoGiveItem(LPITEM item, bool longOwnerShip)
6918. {
6919. if (NULL == item)
6920. {
6921. sys_err ("NULL point.");
6922. return;
6923. }
6924. if (item->GetOwner())
6925. {
6926. sys_err ("item %d 's owner exists!",item->GetID());
6927. return;
6928. }
6930. int cell;
6931. if (item->IsDragonSoul())
6932. {
6933. cell = GetEmptyDragonSoulInventory(item);
6934. }
6935. else
6936. {
6937. cell = GetEmptyInventory (item->GetSize());
6938. }
6940. if (cell != -1)
6941. {
6942. if (item->IsDragonSoul())
6943. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, cell));
6944. else
6945. item->AddToCharacter(this, TItemPos(INVENTORY, cell));
6947. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
6949. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
6950. {
6951. TQuickslot * pSlot;
6953. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
6954. {
6955. TQuickslot slot;
6956. slot.type = QUICKSLOT_TYPE_ITEM;
6957. slot.pos = cell;
6958. SetQuickslot(0, slot);
6959. }
6960. }
6961. }
6962. else
6963. {
6964. item->AddToGround (GetMapIndex(), GetXYZ());
6965. item->StartDestroyEvent();
6967. if (longOwnerShip)
6968. item->SetOwnership (this, 30);
6969. else
6970. item->SetOwnership (this, 25);
6971. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
6972. }
6973. }
6975. LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, BYTE bCount, int iRarePct, bool bMsg)
6976. {
6977. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
6979. if (!p)
6980. return NULL;
6982. DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
6984. if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND)
6985. {
6986. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
6987. {
6988. LPITEM item = GetInventoryItem(i);
6990. if (!item)
6991. continue;
6993. if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item))
6994. {
6995. if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT))
6996. {
6997. if (bCount < p->alValues[1])
6998. bCount = p->alValues[1];
6999. }
7001. BYTE bCount2 = MIN(200 - item->GetCount(), bCount);
7002. bCount -= bCount2;
7004. item->SetCount(item->GetCount() + bCount2);
7006. if (bCount == 0)
7007. {
7008. if (bMsg)
7009. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
7011. return item;
7012. }
7013. }
7014. }
7015. }
7017. LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
7019. if (!item)
7020. {
7021. sys_err("cannot create item by vnum %u (name: %s)", dwItemVnum, GetName());
7022. return NULL;
7023. }
7025. if (item->GetType() == ITEM_BLEND)
7026. {
7027. for (int i=0; i < INVENTORY_MAX_NUM; i++)
7028. {
7029. LPITEM inv_item = GetInventoryItem(i);
7031. if (inv_item == NULL) continue;
7033. if (inv_item->GetType() == ITEM_BLEND)
7034. {
7035. if (inv_item->GetVnum() == item->GetVnum())
7036. {
7037. if (inv_item->GetSocket(0) == item->GetSocket(0) &&
7038. inv_item->GetSocket(1) == item->GetSocket(1) &&
7039. inv_item->GetSocket(2) == item->GetSocket(2) &&
7040. inv_item->GetCount() < ITEM_MAX_COUNT)
7041. {
7042. inv_item->SetCount(inv_item->GetCount() + item->GetCount());
7043. return inv_item;
7044. }
7045. }
7046. }
7047. }
7048. }
7050. int iEmptyCell;
7051. if (item->IsDragonSoul())
7052. {
7053. iEmptyCell = GetEmptyDragonSoulInventory(item);
7054. }
7055. else
7056. iEmptyCell = GetEmptyInventory(item->GetSize());
7058. if (iEmptyCell != -1)
7059. {
7060. if (bMsg)
7061. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
7063. if (item->IsDragonSoul())
7064. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
7065. else
7066. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
7067. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
7069. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
7070. {
7071. TQuickslot * pSlot;
7073. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
7074. {
7075. TQuickslot slot;
7076. slot.type = QUICKSLOT_TYPE_ITEM;
7077. slot.pos = iEmptyCell;
7078. SetQuickslot(0, slot);
7079. }
7080. }
7081. }
7082. else
7083. {
7084. item->AddToGround(GetMapIndex(), GetXYZ());
7085. item->StartDestroyEvent();
7086. // 안티 드랍 flag가 걸려있는 아이템의 경우,
7087. // 인벤에 빈 공간이 없어서 어쩔 수 없이 떨어트리게 되면,
7088. // ownership을 아이템이 사라질 때까지(300초) 유지한다.
7089. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP))
7090. item->SetOwnership(this, 30);
7091. else
7092. item->SetOwnership(this, 35);
7093. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
7094. }
7096. sys_log(0,
7097. "7: %d %d", dwItemVnum, bCount);
7098. return item;
7099. }
7101. bool CHARACTER::GiveItem(LPCHARACTER victim, TItemPos Cell)
7102. {
7103. if (!CanHandleItem())
7104. return false;
7106. LPITEM item = GetItem(Cell);
7108. if (item && !item->IsExchanging())
7109. {
7110. if (victim->CanReceiveItem(this, item))
7111. {
7112. victim->ReceiveItem(this, item);
7113. return true;
7114. }
7115. }
7117. return false;
7118. }
7120. bool CHARACTER::CanReceiveItem(LPCHARACTER from, LPITEM item) const
7121. {
7122. if (IsPC())
7123. return false;
7125. // TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
7126. if (DISTANCE_APPROX(GetX() - from->GetX(), GetY() - from->GetY()) > 2000)
7127. return false;
7128. // END_OF_TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
7130. switch (GetRaceNum())
7131. {
7132. case fishing::CAMPFIRE_MOB:
7133. if (item->GetType() == ITEM_FISH &&
7134. (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
7135. return true;
7136. break;
7138. case fishing::FISHER_MOB:
7139. if (item->GetType() == ITEM_ROD)
7140. return true;
7141. break;
7143. // BUILDING_NPC
7144. case BLACKSMITH_WEAPON_MOB:
7145. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
7146. if (item->GetType() == ITEM_WEAPON &&
7147. item->GetRefinedVnum())
7148. return true;
7149. else
7150. return false;
7151. break;
7153. case BLACKSMITH_ARMOR_MOB:
7154. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
7155. if (item->GetType() == ITEM_ARMOR &&
7156. (item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
7157. item->GetRefinedVnum())
7158. return true;
7159. else
7160. return false;
7161. break;
7163. case BLACKSMITH_ACCESSORY_MOB:
7164. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
7165. if (item->GetType() == ITEM_ARMOR &&
7166. !(item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
7167. item->GetRefinedVnum())
7168. return true;
7169. else
7170. return false;
7171. break;
7172. // END_OF_BUILDING_NPC
7174. case BLACKSMITH_MOB:
7175. if (item->GetRefinedVnum() && item->GetRefineSet() < 500)
7176. {
7177. return true;
7178. }
7179. else
7180. {
7181. return false;
7182. }
7184. case BLACKSMITH2_MOB:
7185. if (item->GetRefineSet() >= 500)
7186. {
7187. return true;
7188. }
7189. else
7190. {
7191. return false;
7192. }
7194. case ALCHEMIST_MOB:
7195. if (item->GetRefinedVnum())
7196. return true;
7197. break;
7199. case 20101:
7200. case 20102:
7201. case 20103:
7202. // 초급 말
7203. if (item->GetVnum() == ITEM_REVIVE_HORSE_1)
7204. {
7205. if (!IsDead())
7206. {
7207. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
7208. return false;
7209. }
7210. return true;
7211. }
7212. else if (item->GetVnum() == ITEM_HORSE_FOOD_1)
7213. {
7214. if (IsDead())
7215. {
7216. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
7217. return false;
7218. }
7219. return true;
7220. }
7221. else if (item->GetVnum() == ITEM_HORSE_FOOD_2 || item->GetVnum() == ITEM_HORSE_FOOD_3)
7222. {
7223. return false;
7224. }
7225. break;
7226. case 20104:
7227. case 20105:
7228. case 20106:
7229. // 중급 말
7230. if (item->GetVnum() == ITEM_REVIVE_HORSE_2)
7231. {
7232. if (!IsDead())
7233. {
7234. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
7235. return false;
7236. }
7237. return true;
7238. }
7239. else if (item->GetVnum() == ITEM_HORSE_FOOD_2)
7240. {
7241. if (IsDead())
7242. {
7243. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
7244. return false;
7245. }
7246. return true;
7247. }
7248. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_3)
7249. {
7250. return false;
7251. }
7252. break;
7253. case 20107:
7254. case 20108:
7255. case 20109:
7256. // 고급 말
7257. if (item->GetVnum() == ITEM_REVIVE_HORSE_3)
7258. {
7259. if (!IsDead())
7260. {
7261. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
7262. return false;
7263. }
7264. return true;
7265. }
7266. else if (item->GetVnum() == ITEM_HORSE_FOOD_3)
7267. {
7268. if (IsDead())
7269. {
7270. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
7271. return false;
7272. }
7273. return true;
7274. }
7275. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_2)
7276. {
7277. return false;
7278. }
7279. break;
7280. }
7282. //if (IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_GIVE))
7283. {
7284. return true;
7285. }
7287. return false;
7288. }
7290. void CHARACTER::ReceiveItem(LPCHARACTER from, LPITEM item)
7291. {
7292. if (IsPC())
7293. return;
7295. switch (GetRaceNum())
7296. {
7297. case fishing::CAMPFIRE_MOB:
7298. if (item->GetType() == ITEM_FISH && (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
7299. fishing::Grill(from, item);
7300. else
7301. {
7302. // TAKE_ITEM_BUG_FIX
7303. from->SetQuestNPCID(GetVID());
7304. // END_OF_TAKE_ITEM_BUG_FIX
7305. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
7306. }
7307. break;
7309. // DEVILTOWER_NPC
7310. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
7311. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
7312. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
7313. if (item->GetRefinedVnum() != 0 && item->GetRefineSet() != 0 && item->GetRefineSet() < 500)
7314. {
7315. from->SetRefineNPC(this);
7316. from->RefineInformation(item->GetCell(), REFINE_TYPE_MONEY_ONLY);
7317. }
7318. else
7319. {
7320. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
7321. }
7322. break;
7323. // END_OF_DEVILTOWER_NPC
7325. case BLACKSMITH_MOB:
7326. case BLACKSMITH2_MOB:
7327. case BLACKSMITH_WEAPON_MOB:
7328. case BLACKSMITH_ARMOR_MOB:
7329. case BLACKSMITH_ACCESSORY_MOB:
7330. if (item->GetRefinedVnum())
7331. {
7332. from->SetRefineNPC(this);
7333. from->RefineInformation(item->GetCell(), REFINE_TYPE_NORMAL);
7334. }
7335. else
7336. {
7337. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
7338. }
7339. break;
7341. case 20101:
7342. case 20102:
7343. case 20103:
7344. case 20104:
7345. case 20105:
7346. case 20106:
7347. case 20107:
7348. case 20108:
7349. case 20109:
7350. if (item->GetVnum() == ITEM_REVIVE_HORSE_1 ||
7351. item->GetVnum() == ITEM_REVIVE_HORSE_2 ||
7352. item->GetVnum() == ITEM_REVIVE_HORSE_3)
7353. {
7354. from->ReviveHorse();
7355. item->SetCount(item->GetCount()-1);
7356. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말에게 선초를 주었습니다."));
7357. }
7358. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 ||
7359. item->GetVnum() == ITEM_HORSE_FOOD_2 ||
7360. item->GetVnum() == ITEM_HORSE_FOOD_3)
7361. {
7362. from->FeedHorse();
7363. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말에게 사료를 주었습니다."));
7364. item->SetCount(item->GetCount()-1);
7365. EffectPacket(SE_HPUP_RED);
7366. }
7367. break;
7369. default:
7370. sys_log(0, "TakeItem %s %d %s", from->GetName(), GetRaceNum(), item->GetName());
7371. from->SetQuestNPCID(GetVID());
7372. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
7373. break;
7374. }
7375. }
7377. bool CHARACTER::IsEquipUniqueItem(DWORD dwItemVnum) const
7378. {
7379. {
7380. LPITEM u = GetWear(WEAR_UNIQUE1);
7382. if (u && u->GetVnum() == dwItemVnum)
7383. return true;
7384. }
7386. {
7387. LPITEM u = GetWear(WEAR_UNIQUE2);
7389. if (u && u->GetVnum() == dwItemVnum)
7390. return true;
7391. }
7393. {
7394. LPITEM u = GetWear(WEAR_COSTUME_MOUNT);
7396. if (u && u->GetVnum() == dwItemVnum)
7397. return true;
7398. }
7400. // 언어반지인 경우 언어반지(견본) 인지도 체크한다.
7401. if (dwItemVnum == UNIQUE_ITEM_RING_OF_LANGUAGE)
7402. return IsEquipUniqueItem(UNIQUE_ITEM_RING_OF_LANGUAGE_SAMPLE);
7404. return false;
7405. }
7407. // CHECK_UNIQUE_GROUP
7408. bool CHARACTER::IsEquipUniqueGroup(DWORD dwGroupVnum) const
7409. {
7410. {
7411. LPITEM u = GetWear(WEAR_UNIQUE1);
7413. if (u && u->GetSpecialGroup() == (int) dwGroupVnum)
7414. return true;
7415. }
7417. {
7418. LPITEM u = GetWear(WEAR_UNIQUE2);
7420. if (u && u->GetSpecialGroup() == (int) dwGroupVnum)
7421. return true;
7422. }
7424. {
7425. LPITEM u = GetWear(WEAR_COSTUME_MOUNT);
7427. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
7428. return true;
7429. }
7431. return false;
7432. }
7433. // END_OF_CHECK_UNIQUE_GROUP
7435. void CHARACTER::SetRefineMode(int iAdditionalCell)
7436. {
7437. m_iRefineAdditionalCell = iAdditionalCell;
7438. m_bUnderRefine = true;
7439. }
7441. void CHARACTER::ClearRefineMode()
7442. {
7443. m_bUnderRefine = false;
7444. SetRefineNPC( NULL );
7445. }
7447. bool CHARACTER::InformationSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums,
7448. std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count)
7449. {
7450. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
7451. if (!pGroup)
7452. {
7453. return false;
7454. }
7456. bool bSuccess;
7457. DWORD CountTotal = pGroup->GetItemGroup();
7459. for (int i = 0; i < CountTotal; i++)
7460. {
7461. DWORD dwVnum = pGroup->GetVnum(i);
7462. DWORD dwCount = pGroup->GetCount(i);
7463. bSuccess = true;
7465. if (bSuccess)
7466. {
7467. dwItemVnums.push_back(dwVnum);
7468. dwItemCounts.push_back(dwCount);
7470. }
7471. count = CountTotal;
7473. }
7474. return bSuccess;
7476. }
7478. bool CHARACTER::GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums,
7479. std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count)
7480. {
7481. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
7483. if (!pGroup)
7484. {
7485. sys_err("cannot find special item group %d", dwGroupNum);
7486. return false;
7487. }
7489. std::vector <int> idxes;
7490. int n = pGroup->GetMultiIndex(idxes);
7492. bool bSuccess;
7494. for (int i = 0; i < n; i++)
7495. {
7496. bSuccess = false;
7497. int idx = idxes[i];
7498. DWORD dwVnum = pGroup->GetVnum(idx);
7499. DWORD dwCount = pGroup->GetCount(idx);
7500. int iRarePct = pGroup->GetRarePct(idx);
7501. LPITEM item_get = NULL;
7502. switch (dwVnum)
7503. {
7504. case CSpecialItemGroup::GOLD:
7505. PointChange(POINT_GOLD, dwCount);
7506. LogManager::instance().CharLog(this, dwCount, "TREASURE_GOLD", "");
7508. bSuccess = true;
7509. break;
7510. case CSpecialItemGroup::EXP:
7511. {
7512. PointChange(POINT_EXP, dwCount);
7513. LogManager::instance().CharLog(this, dwCount, "TREASURE_EXP", "");
7515. bSuccess = true;
7516. }
7517. break;
7519. case CSpecialItemGroup::MOB:
7520. {
7521. sys_log(0, "CSpecialItemGroup::MOB %d", dwCount);
7522. int x = GetX() + number(-500, 500);
7523. int y = GetY() + number(-500, 500);
7525. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(dwCount, GetMapIndex(), x, y, 0, true, -1);
7526. if (ch)
7527. ch->SetAggressive();
7528. bSuccess = true;
7529. }
7530. break;
7531. case CSpecialItemGroup::SLOW:
7532. {
7533. sys_log(0, "CSpecialItemGroup::SLOW %d", -(int)dwCount);
7534. AddAffect(AFFECT_SLOW, POINT_MOV_SPEED, -(int)dwCount, AFF_SLOW, 300, 0, true);
7535. bSuccess = true;
7536. }
7537. break;
7538. case CSpecialItemGroup::DRAIN_HP:
7539. {
7540. int iDropHP = GetMaxHP()*dwCount/100;
7541. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
7542. iDropHP = MIN(iDropHP, GetHP()-1);
7543. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
7544. PointChange(POINT_HP, -iDropHP);
7545. bSuccess = true;
7546. }
7547. break;
7548. case CSpecialItemGroup::POISON:
7549. {
7550. AttackedByPoison(NULL);
7551. bSuccess = true;
7552. }
7553. break;
7555. case CSpecialItemGroup::MOB_GROUP:
7556. {
7557. int sx = GetX() - number(300, 500);
7558. int sy = GetY() - number(300, 500);
7559. int ex = GetX() + number(300, 500);
7560. int ey = GetY() + number(300, 500);
7561. CHARACTER_MANAGER::instance().SpawnGroup(dwCount, GetMapIndex(), sx, sy, ex, ey, NULL, true);
7563. bSuccess = true;
7564. }
7565. break;
7566. default:
7567. {
7568. item_get = AutoGiveItem(dwVnum, dwCount, iRarePct);
7570. if (item_get)
7571. {
7572. bSuccess = true;
7573. }
7574. }
7575. break;
7576. }
7578. if (bSuccess)
7579. {
7580. dwItemVnums.push_back(dwVnum);
7581. dwItemCounts.push_back(dwCount);
7582. item_gets.push_back(item_get);
7583. count++;
7585. }
7586. else
7587. {
7588. return false;
7589. }
7590. }
7591. return bSuccess;
7592. }
7594. // NEW_HAIR_STYLE_ADD
7595. bool CHARACTER::ItemProcess_Hair(LPITEM item, int iDestCell)
7596. {
7597. if (item->CheckItemUseLevel(GetLevel()) == false)
7598. {
7599. // 레벨 제한에 걸림
7600. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 이 머리를 사용할 수 없는 레벨입니다."));
7601. return false;
7602. }
7604. DWORD hair = item->GetVnum();
7606. switch (GetJob())
7607. {
7608. case JOB_WARRIOR :
7609. hair -= 72000; // 73001 - 72000 = 1001 부터 헤어 번호 시작
7610. break;
7612. case JOB_ASSASSIN :
7613. hair -= 71250;
7614. break;
7616. case JOB_SURA :
7617. hair -= 70500;
7618. break;
7620. case JOB_SHAMAN :
7621. hair -= 69750;
7622. break;
7624. default :
7625. return false;
7626. break;
7627. }
7629. if (hair == GetPart(PART_HAIR))
7630. {
7631. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("동일한 머리 스타일로는 교체할 수 없습니다."));
7632. return true;
7633. }
7635. item->SetCount(item->GetCount() - 1);
7637. SetPart(PART_HAIR, hair);
7638. UpdatePacket();
7640. return true;
7641. }
7642. // END_NEW_HAIR_STYLE_ADD
7644. bool CHARACTER::ItemProcess_Polymorph(LPITEM item)
7645. {
7646. if (IsPolymorphed())
7647. {
7648. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 둔갑중인 상태입니다."));
7649. return false;
7650. }
7652. if (true == IsRiding())
7653. {
7654. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑할 수 없는 상태입니다."));
7655. return false;
7656. }
7658. DWORD dwVnum = item->GetSocket(0);
7660. if (dwVnum == 0)
7661. {
7662. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("잘못된 둔갑 아이템입니다."));
7663. item->SetCount(item->GetCount()-1);
7664. return false;
7665. }
7667. const CMob* pMob = CMobManager::instance().Get(dwVnum);
7669. if (pMob == NULL)
7670. {
7671. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("잘못된 둔갑 아이템입니다."));
7672. item->SetCount(item->GetCount()-1);
7673. return false;
7674. }
7676. switch (item->GetVnum())
7677. {
7678. case 70104 :
7679. case 70105 :
7680. case 70106 :
7681. case 70107 :
7682. case 71093 :
7683. {
7684. // 둔갑구 처리
7685. sys_log(0, "USE_POLYMORPH_BALL PID(%d) vnum(%d)", GetPlayerID(), dwVnum);
7687. // 레벨 제한 체크
7688. int iPolymorphLevelLimit = MAX(0, 20 - GetLevel() * 3 / 10);
7689. if (pMob->m_table.bLevel >= GetLevel() + iPolymorphLevelLimit)
7690. {
7691. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("나보다 너무 높은 레벨의 몬스터로는 변신 할 수 없습니다."));
7692. return false;
7693. }
7695. int iDuration = GetSkillLevel(POLYMORPH_SKILL_ID) == 0 ? 5 : (5 + (5 + GetSkillLevel(POLYMORPH_SKILL_ID)/40 * 25));
7696. iDuration *= 60;
7698. DWORD dwBonus = 0;
7700. if (true == LC_IsYMIR() || true == LC_IsKorea())
7701. {
7702. dwBonus = GetSkillLevel(POLYMORPH_SKILL_ID) + 60;
7703. }
7704. else
7705. {
7706. dwBonus = (2 + GetSkillLevel(POLYMORPH_SKILL_ID)/40) * 100;
7707. }
7709. AddAffect(AFFECT_POLYMORPH, POINT_POLYMORPH, dwVnum, AFF_POLYMORPH, iDuration, 0, true);
7710. AddAffect(AFFECT_POLYMORPH, POINT_ATT_BONUS, dwBonus, AFF_POLYMORPH, iDuration, 0, false);
7712. item->SetCount(item->GetCount()-1);
7713. }
7714. break;
7716. case 50322:
7717. {
7718. // 보류
7720. // 둔갑서 처리
7721. // 소켓0 소켓1 소켓2
7722. // 둔갑할 몬스터 번호 수련정도 둔갑서 레벨
7723. sys_log(0, "USE_POLYMORPH_BOOK: %s(%u) vnum(%u)", GetName(), GetPlayerID(), dwVnum);
7725. if (CPolymorphUtils::instance().PolymorphCharacter(this, item, pMob) == true)
7726. {
7727. CPolymorphUtils::instance().UpdateBookPracticeGrade(this, item);
7728. }
7729. else
7730. {
7731. }
7732. }
7733. break;
7735. default :
7736. sys_err("POLYMORPH invalid item passed PID(%d) vnum(%d)", GetPlayerID(), item->GetOriginalVnum());
7737. return false;
7738. }
7740. return true;
7741. }
7743. bool CHARACTER::CanDoCube() const
7744. {
7745. if (m_bIsObserver) return false;
7746. if (GetShop()) return false;
7747. if (GetMyShop()) return false;
7748. if (m_bUnderRefine) return false;
7749. if (IsWarping()) return false;
7750. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
7751. if (GetOfflineShop()) return false;
7752. #endif
7754. return true;
7755. }
7757. bool CHARACTER::UnEquipSpecialRideUniqueItem()
7758. {
7759. LPITEM Unique1 = GetWear(WEAR_UNIQUE1);
7760. LPITEM Unique2 = GetWear(WEAR_UNIQUE2);
7761. LPITEM Unique3 = GetWear(WEAR_COSTUME_MOUNT);
7763. if( NULL != Unique1 )
7764. {
7765. if( UNIQUE_GROUP_SPECIAL_RIDE == Unique1->GetSpecialGroup() )
7766. {
7767. return UnequipItem(Unique1);
7768. }
7769. }
7771. if( NULL != Unique2 )
7772. {
7773. if( UNIQUE_GROUP_SPECIAL_RIDE == Unique2->GetSpecialGroup() )
7774. {
7775. return UnequipItem(Unique2);
7776. }
7777. }
7779. if (NULL != Unique3)
7780. {
7781. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique3->GetSpecialGroup())
7782. {
7783. return UnequipItem(Unique3);
7784. }
7785. }
7787. return true;
7788. }
7790. void CHARACTER::AutoRecoveryItemProcess(const EAffectTypes type)
7791. {
7792. if (true == IsDead() || true == IsStun())
7793. return;
7795. if (false == IsPC())
7796. return;
7798. if (AFFECT_AUTO_HP_RECOVERY != type && AFFECT_AUTO_SP_RECOVERY != type)
7799. return;
7801. if (NULL != FindAffect(AFFECT_STUN))
7802. return;
7804. {
7805. const DWORD stunSkills[] = { SKILL_TANHWAN, SKILL_GEOMPUNG, SKILL_BYEURAK, SKILL_GIGUNG };
7807. for (size_t i=0 ; i < sizeof(stunSkills)/sizeof(DWORD) ; ++i)
7808. {
7809. const CAffect* p = FindAffect(stunSkills[i]);
7811. if (NULL != p && AFF_STUN == p->dwFlag)
7812. return;
7813. }
7814. }
7816. const CAffect* pAffect = FindAffect(type);
7817. const size_t idx_of_amount_of_used = 1;
7818. const size_t idx_of_amount_of_full = 2;
7820. if (NULL != pAffect)
7821. {
7822. LPITEM pItem = FindItemByID(pAffect->dwFlag);
7824. if (NULL != pItem && true == pItem->GetSocket(0))
7825. {
7826. if (false == CArenaManager::instance().IsArenaMap(GetMapIndex()))
7827. {
7828. const long amount_of_used = pItem->GetSocket(idx_of_amount_of_used);
7829. const long amount_of_full = pItem->GetSocket(idx_of_amount_of_full);
7831. const int32_t avail = amount_of_full - amount_of_used;
7833. int32_t amount = 0;
7835. if (AFFECT_AUTO_HP_RECOVERY == type)
7836. {
7837. amount = GetMaxHP() - (GetHP() + GetPoint(POINT_HP_RECOVERY));
7838. }
7839. else if (AFFECT_AUTO_SP_RECOVERY == type)
7840. {
7841. amount = GetMaxSP() - (GetSP() + GetPoint(POINT_SP_RECOVERY));
7842. }
7844. if (amount > 0)
7845. {
7846. if (avail > amount)
7847. {
7848. const int pct_of_used = amount_of_used * 100 / amount_of_full;
7849. const int pct_of_will_used = (amount_of_used + amount) * 100 / amount_of_full;
7851. bool bLog = false;
7852. // 사용량의 10% 단위로 로그를 남김
7853. // (사용량의 %에서, 십의 자리가 바뀔 때마다 로그를 남김.)
7854. if ((pct_of_will_used / 10) - (pct_of_used / 10) >= 1)
7855. bLog = true;
7856. pItem->SetSocket(idx_of_amount_of_used, amount_of_used + amount, bLog);
7857. }
7858. else
7859. {
7860. amount = avail;
7862. ITEM_MANAGER::instance().RemoveItem( pItem );
7863. }
7865. if (AFFECT_AUTO_HP_RECOVERY == type)
7866. {
7867. PointChange( POINT_HP_RECOVERY, amount );
7868. EffectPacket( SE_AUTO_HPUP );
7869. }
7870. else if (AFFECT_AUTO_SP_RECOVERY == type)
7871. {
7872. PointChange( POINT_SP_RECOVERY, amount );
7873. EffectPacket( SE_AUTO_SPUP );
7874. }
7875. }
7876. }
7877. else
7878. {
7879. pItem->Lock(false);
7880. pItem->SetSocket(0, false);
7881. RemoveAffect( const_cast<CAffect*>(pAffect) );
7882. }
7883. }
7884. else
7885. {
7886. RemoveAffect( const_cast<CAffect*>(pAffect) );
7887. }
7888. }
7889. }
7891. bool CHARACTER::IsValidItemPosition(TItemPos Pos) const
7892. {
7893. BYTE window_type = Pos.window_type;
7894. WORD cell = Pos.cell;
7896. switch (window_type)
7897. {
7898. case RESERVED_WINDOW:
7899. return false;
7901. case INVENTORY:
7902. case EQUIPMENT:
7903. return cell < (INVENTORY_AND_EQUIP_SLOT_MAX);
7905. case DRAGON_SOUL_INVENTORY:
7906. return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
7908. case SAFEBOX:
7909. if (NULL != m_pkSafebox)
7910. return m_pkSafebox->IsValidPosition(cell);
7911. else
7912. return false;
7914. case MALL:
7915. if (NULL != m_pkMall)
7916. return m_pkMall->IsValidPosition(cell);
7917. else
7918. return false;
7919. default:
7920. return false;
7921. }
7922. }
7925. // 귀찮아서 만든 매크로.. exp가 true면 msg를 출력하고 return false 하는 매크로 (일반적인 verify 용도랑은 return 때문에 약간 반대라 이름때문에 헷갈릴 수도 있겠다..)
7926. #define VERIFY_MSG(exp, msg) \
7927. if (true == (exp)) { \
7928. ChatPacket(CHAT_TYPE_INFO, LC_TEXT(msg)); \
7929. return false; \
7930. }
7933. /// 현재 캐릭터의 상태를 바탕으로 주어진 item을 착용할 수 있는 지 확인하고, 불가능 하다면 캐릭터에게 이유를 알려주는 함수
7934. bool CHARACTER::CanEquipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
7935. {
7936. const TItemTable* itemTable = item->GetProto();
7937. BYTE itemType = item->GetType();
7938. BYTE itemSubType = item->GetSubType();
7939. #ifdef __WEAPON_COSTUME_SYSTEM__
7941. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW)
7942. {
7943. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
7944. if (pkItem)
7945. {
7946. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
7947. return false;
7948. }
7949. }
7950. else if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_WEAPON)
7951. {
7952. LPITEM pkItem = GetWear(WEAR_WEAPON);
7953. if (!pkItem)
7954. {
7955. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't wear a costume weapon without have a weapon weared."));
7956. return false;
7957. }
7958. else if (item->GetValue(3) != pkItem->GetSubType())
7959. {
7960. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't wear a costume weapon who has different type of your weapon."));
7961. return false;
7962. }
7963. else if (pkItem->GetType() == ITEM_ROD || pkItem->GetType() == ITEM_PICK) // // block fish rod and pick
7965. {
7966. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nu poti pune skin de arma pe undita, esti nebun? :)) "));
7967. return false;
7968. }
7969. }
7971. //if (item->GetType() == ITEM_ROD || item->GetType() == ITEM_PICK)
7972. //{
7973. // LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
7974. // if (pkItem)
7975. // {
7976. // ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
7977. // return false;
7978. // }
7979. //}
7980. #endif
7982. #ifdef COSTUME_WEAPON
7983. if (item->GetType() == ITEM_COSTUME && item->GetSubType() >= COSTUME_WEAPON_SWORD)
7984. {
7985. LPITEM weapon = GetWear(WEAR_WEAPON);
7986. if (!weapon)
7987. {
7988. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You must equip weapon first"));
7989. return false;
7990. }
7991. if (weapon->GetSubType() + COSTUME_WEAPON_SWORD != item->GetSubType())
7992. {
7993. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You must equip costume weapon with same type of weapon"));
7994. return false;
7995. }
7996. }
7997. if (item->GetType() == ITEM_WEAPON)
7998. {
7999. LPITEM weapon = GetWear(WEAR_COSTUME_WEAPON);
8000. if (weapon)
8001. {
8002. if (weapon->GetSubType() - COSTUME_WEAPON_SWORD != item->GetSubType())
8003. {
8004. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You must equip weapon with same type of costume"));
8005. return false;
8006. }
8007. }
8008. }
8009. #endif
8010. switch (GetJob())
8011. {
8012. case JOB_WARRIOR:
8013. if (item->GetAntiFlag() & ITEM_ANTIFLAG_WARRIOR)
8014. return false;
8015. break;
8017. case JOB_ASSASSIN:
8018. if (item->GetAntiFlag() & ITEM_ANTIFLAG_ASSASSIN)
8019. return false;
8020. break;
8022. case JOB_SHAMAN:
8023. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SHAMAN)
8024. return false;
8025. break;
8027. case JOB_SURA:
8028. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SURA)
8029. return false;
8030. break;
8031. }
8033. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
8034. {
8035. long limit = itemTable->aLimits[i].lValue;
8036. switch (itemTable->aLimits[i].bType)
8037. {
8038. case LIMIT_LEVEL:
8039. if (GetLevel() < limit)
8040. {
8041. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨이 낮아 착용할 수 없습니다."));
8042. return false;
8043. }
8044. break;
8046. case LIMIT_STR:
8047. if (GetPoint(POINT_ST) < limit)
8048. {
8049. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("근력이 낮아 착용할 수 없습니다."));
8050. return false;
8051. }
8052. break;
8054. case LIMIT_INT:
8055. if (GetPoint(POINT_IQ) < limit)
8056. {
8057. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("지능이 낮아 착용할 수 없습니다."));
8058. return false;
8059. }
8060. break;
8062. case LIMIT_DEX:
8063. if (GetPoint(POINT_DX) < limit)
8064. {
8065. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("민첩이 낮아 착용할 수 없습니다."));
8066. return false;
8067. }
8068. break;
8070. case LIMIT_CON:
8071. if (GetPoint(POINT_HT) < limit)
8072. {
8073. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("체력이 낮아 착용할 수 없습니다."));
8074. return false;
8075. }
8076. break;
8077. }
8078. }
8080. if (item->GetWearFlag() & WEARABLE_UNIQUE)
8081. {
8082. if ((GetWear(WEAR_UNIQUE1) && GetWear(WEAR_UNIQUE1)->IsSameSpecialGroup(item)) ||
8083. (GetWear(WEAR_UNIQUE2) && GetWear(WEAR_UNIQUE2)->IsSameSpecialGroup(item)) ||
8084. (GetWear(WEAR_COSTUME_MOUNT) && GetWear(WEAR_COSTUME_MOUNT)->IsSameSpecialGroup(item)))
8085. {
8086. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 종류의 유니크 아이템 두 개를 동시에 장착할 수 없습니다."));
8087. return false;
8088. }
8090. if (marriage::CManager::instance().IsMarriageUniqueItem(item->GetVnum()) &&
8091. !marriage::CManager::instance().IsMarried(GetPlayerID()))
8092. {
8093. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("결혼하지 않은 상태에서 예물을 착용할 수 없습니다."));
8094. return false;
8095. }
8097. }
8098. if (item->GetType() == ITEM_RING) // ring check for two same rings
8099. {
8100. LPITEM ringItems[2] = { GetWear(WEAR_RING1), GetWear(WEAR_RING2) };
8101. for (int i = 0; i < 2; i++)
8102. {
8103. if (ringItems[i]) // if that item is equipped
8104. {
8105. if (ringItems[i]->GetVnum() == item->GetVnum())
8106. {
8107. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nu poti echipa acest item de doua ori!"));
8108. return false;
8109. }
8110. }
8111. }
8112. }
8113. return true;
8114. }
8116. /// 현재 캐릭터의 상태를 바탕으로 착용 중인 item을 벗을 수 있는 지 확인하고, 불가능 하다면 캐릭터에게 이유를 알려주는 함수
8117. bool CHARACTER::CanUnequipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
8118. {
8120. if (ITEM_BELT == item->GetType())
8121. VERIFY_MSG(CBeltInventoryHelper::IsExistItemInBeltInventory(this), "벨트 인벤토리에 아이템이 존재하면 해제할 수 없습니다.");
8123. // 영원히 해제할 수 없는 아이템
8124. if (IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
8125. return false;
8126. #ifdef __WEAPON_COSTUME_SYSTEM__
8127. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW)
8128. {
8129. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
8130. if (pkItem)
8131. {
8132. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
8133. return false;
8134. }
8135. }
8136. #endif
8137. #ifdef COSTUME_WEAPON
8138. if (GetWear(WEAR_COSTUME_WEAPON) && item->GetType() == ITEM_WEAPON)
8139. {
8140. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You must unequip costume weapon first"));
8141. return false;
8142. }
8143. #endif
8145. // 아이템 unequip시 인벤토리로 옮길 때 빈 자리가 있는 지 확인
8146. {
8147. int pos = -1;
8149. if (item->IsDragonSoul())
8150. pos = GetEmptyDragonSoulInventory(item);
8151. else
8152. pos = GetEmptyInventory(item->GetSize());
8154. VERIFY_MSG( -1 == pos, "소지품에 빈 공간이 없습니다." );
8155. }
8156. return true;
8157. }