1. #include "stdafx.h"
2. #include <sstream>
4. #include "utils.h"
5. #include "config.h"
6. #include "vector.h"
7. #include "char.h"
8. #include "char_manager.h"
9. #include "battle.h"
10. #include "desc.h"
11. #include "desc_manager.h"
12. #include "packet.h"
13. #include "affect.h"
14. #include "item.h"
15. #include "sectree_manager.h"
16. #include "mob_manager.h"
17. #include "start_position.h"
18. #include "party.h"
19. #include "buffer_manager.h"
20. #include "guild.h"
21. #include "log.h"
22. #include "unique_item.h"
23. #include "questmanager.h"
25. extern int test_server;
27. static const DWORD s_adwSubSkillVnums[] =
28. {
29. SKILL_LEADERSHIP,
30. SKILL_COMBO,
31. SKILL_MINING,
32. SKILL_LANGUAGE1,
33. SKILL_LANGUAGE2,
34. SKILL_LANGUAGE3,
35. SKILL_POLYMORPH,
36. SKILL_HORSE,
37. SKILL_HORSE_SUMMON,
38. SKILL_HORSE_WILDATTACK,
39. SKILL_HORSE_CHARGE,
40. SKILL_HORSE_ESCAPE,
41. SKILL_HORSE_WILDATTACK_RANGE,
42. SKILL_ADD_HP,
43. SKILL_RESIST_PENETRATE
44. };
46. time_t CHARACTER::GetSkillNextReadTime(DWORD dwVnum) const
47. {
48. if (dwVnum >= SKILL_MAX_NUM)
49. {
50. sys_err("vnum overflow (vnum: %u)", dwVnum);
51. return 0;
52. }
54. return m_pSkillLevels ? m_pSkillLevels[dwVnum].tNextRead : 0;
55. }
57. void CHARACTER::SetSkillNextReadTime(DWORD dwVnum, time_t time)
58. {
59. if (m_pSkillLevels && dwVnum < SKILL_MAX_NUM)
60. m_pSkillLevels[dwVnum].tNextRead = time;
61. }
63. bool TSkillUseInfo::HitOnce(DWORD dwVnum)
64. {
65. // ¾²Áöµµ¾Ê¾ÒÀ¸¸é ¶§¸®Áöµµ ¸øÇÑ´Ù.
66. if (!bUsed)
67. return false;
69. sys_log(1, "__HitOnce NextUse %u current %u count %d scount %d", dwNextSkillUsableTime, get_dword_time(), iHitCount, iSplashCount);
71. if (dwNextSkillUsableTime && dwNextSkillUsableTime<get_dword_time() && dwVnum != SKILL_MUYEONG && dwVnum != SKILL_HORSE_WILDATTACK)
72. {
73. sys_log(1, "__HitOnce can't hit");
75. return false;
76. }
78. if (iHitCount == -1)
79. {
80. sys_log(1, "__HitOnce OK %d %d %d", dwNextSkillUsableTime, get_dword_time(), iHitCount);
81. return true;
82. }
84. if (iHitCount)
85. {
86. sys_log(1, "__HitOnce OK %d %d %d", dwNextSkillUsableTime, get_dword_time(), iHitCount);
87. iHitCount--;
88. return true;
89. }
90. return false;
91. }
95. bool TSkillUseInfo::UseSkill(bool isGrandMaster, DWORD vid, DWORD dwCooltime, int splashcount, int hitcount, int range)
96. {
97. this->isGrandMaster = isGrandMaster;
98. DWORD dwCur = get_dword_time();
100. // ¾ÆÁ÷ ÄðŸÀÓÀÌ ³¡³ªÁö ¾Ê¾Ò´Ù.
101. if (bUsed && dwNextSkillUsableTime > dwCur)
102. {
103. sys_log(0, "cooltime is not over delta %u", dwNextSkillUsableTime - dwCur);
104. iHitCount = 0;
105. return false;
106. }
108. bUsed = true;
110. if (dwCooltime)
111. dwNextSkillUsableTime = dwCur + dwCooltime;
112. else
113. dwNextSkillUsableTime = 0;
115. iRange = range;
116. iMaxHitCount = iHitCount = hitcount;
118. if (test_server)
119. sys_log(0, "UseSkill NextUse %u current %u cooltime %d hitcount %d/%d", dwNextSkillUsableTime, dwCur, dwCooltime, iHitCount, iMaxHitCount);
121. dwVID = vid;
122. iSplashCount = splashcount;
123. return true;
124. }
126. int CHARACTER::GetChainLightningMaxCount() const
127. {
128. return aiChainLightningCountBySkillLevel[MIN(SKILL_MAX_LEVEL, GetSkillLevel(SKILL_CHAIN))];
129. }
131. void CHARACTER::SetAffectedEunhyung()
132. {
133. m_dwAffectedEunhyungLevel = GetSkillPower(SKILL_EUNHYUNG);
134. }
136. void CHARACTER::SetSkillGroup(BYTE bSkillGroup)
137. {
138. if (bSkillGroup > 2)
139. return;
141. if (GetLevel() < 5)
142. return;
144. m_points.skill_group = bSkillGroup;
146. TPacketGCChangeSkillGroup p;
147. p.header = HEADER_GC_SKILL_GROUP;
148. p.skill_group = m_points.skill_group;
150. GetDesc()->Packet(&p, sizeof(TPacketGCChangeSkillGroup));
151. }
153. int CHARACTER::ComputeCooltime(int time)
154. {
155. return CalculateDuration(GetPoint(POINT_CASTING_SPEED), time);
156. }
158. void CHARACTER::SkillLevelPacket()
159. {
160. if (!GetDesc())
161. return;
163. TPacketGCSkillLevel pack;
165. pack.bHeader = HEADER_GC_SKILL_LEVEL;
166. thecore_memcpy(&pack.skills, m_pSkillLevels, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
167. GetDesc()->Packet(&pack, sizeof(TPacketGCSkillLevel));
168. }
170. void CHARACTER::SetSkillLevel(DWORD dwVnum, BYTE bLev)
171. {
172. if (NULL == m_pSkillLevels)
173. return;
175. if (dwVnum >= SKILL_MAX_NUM)
176. {
177. sys_err("vnum overflow (vnum %u)", dwVnum);
178. return;
179. }
181. m_pSkillLevels[dwVnum].bLevel = MIN(40, bLev);
183. if (bLev >= 40)
184. m_pSkillLevels[dwVnum].bMasterType = SKILL_PERFECT_MASTER;
185. else if (bLev >= 30)
186. m_pSkillLevels[dwVnum].bMasterType = SKILL_GRAND_MASTER;
187. else if (bLev >= 20)
188. m_pSkillLevels[dwVnum].bMasterType = SKILL_MASTER;
189. else
190. m_pSkillLevels[dwVnum].bMasterType = SKILL_NORMAL;
191. }
193. bool CHARACTER::IsLearnableSkill(DWORD dwSkillVnum) const
194. {
195. const CSkillProto * pkSkill = CSkillManager::instance().Get(dwSkillVnum);
197. if (!pkSkill)
198. return false;
200. if (GetSkillLevel(dwSkillVnum) >= SKILL_MAX_LEVEL)
201. return false;
203. if (pkSkill->dwType == 0)
204. {
205. if (GetSkillLevel(dwSkillVnum) >= pkSkill->bMaxLevel)
206. return false;
208. return true;
209. }
211. if (pkSkill->dwType == 5)
212. {
213. if (dwSkillVnum == SKILL_HORSE_WILDATTACK_RANGE && GetJob() != JOB_ASSASSIN)
214. return false;
216. return true;
217. }
219. if (GetSkillGroup() == 0)
220. return false;
222. if (pkSkill->dwType - 1 == GetJob())
223. return true;
225. if (6 == pkSkill->dwType)
226. {
227. if (SKILL_7_A_ANTI_TANHWAN <= dwSkillVnum && dwSkillVnum <= SKILL_7_D_ANTI_YONGBI)
228. {
229. for (int i=0 ; i < 4 ; i++)
230. {
231. if (unsigned(SKILL_7_A_ANTI_TANHWAN + i) != dwSkillVnum)
232. {
233. if (0 != GetSkillLevel(SKILL_7_A_ANTI_TANHWAN + i))
234. {
235. return false;
236. }
237. }
238. }
240. return true;
241. }
243. if (SKILL_8_A_ANTI_GIGONGCHAM <= dwSkillVnum && dwSkillVnum <= SKILL_8_D_ANTI_BYEURAK)
244. {
245. for (int i=0 ; i < 4 ; i++)
246. {
247. if (unsigned(SKILL_8_A_ANTI_GIGONGCHAM + i) != dwSkillVnum)
248. {
249. if (0 != GetSkillLevel(SKILL_8_A_ANTI_GIGONGCHAM + i))
250. return false;
251. }
252. }
254. return true;
255. }
256. }
258. return false;
259. }
261. // ADD_GRANDMASTER_SKILL
262. bool CHARACTER::LearnGrandMasterSkill(DWORD dwSkillVnum)
263. {
264. CSkillProto * pkSk = CSkillManager::instance().Get(dwSkillVnum);
266. if (!pkSk)
267. return false;
269. if (!IsLearnableSkill(dwSkillVnum))
270. {
271. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÇÒ ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù."));
272. return false;
273. }
275. sys_log(0, "learn grand master skill[%d] cur %d, next %d", dwSkillVnum, get_global_time(), GetSkillNextReadTime(dwSkillVnum));
277. /*
278. if (get_global_time() < GetSkillNextReadTime(dwSkillVnum))
279. {
280. if (!(test_server && quest::CQuestManager::instance().GetEventFlag("no_read_delay")))
281. {
282. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
283. {
284. // Á־ȼú¼­ »ç¿ëÁß¿¡´Â ½Ã°£ Á¦ÇÑ ¹«½Ã
285. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
286. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á־ȼú¼­¸¦ ÅëÇØ ÁÖÈ­ÀÔ¸¶¿¡¼­ ºüÁ®³ª¿Ô½À´Ï´Ù."));
287. }
288. else
289. {
290. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
291. return false;
292. }
293. }
294. }
295. */
297. // bTypeÀÌ 0À̸é óÀ½ºÎÅÍ Ã¥À¸·Î ¼ö·Ã °¡´É
298. if (pkSk->dwType == 0)
299. {
300. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±×·£µå ¸¶½ºÅÍ ¼ö·ÃÀ» ÇÒ ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù."));
301. return false;
302. }
304. if (GetSkillMasterType(dwSkillVnum) != SKILL_GRAND_MASTER)
305. {
306. if (GetSkillMasterType(dwSkillVnum) > SKILL_GRAND_MASTER)
307. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÆÛÆåÆ® ¸¶½ºÅÍµÈ ½ºÅ³ÀÔ´Ï´Ù. ´õ ÀÌ»ó ¼ö·Ã ÇÒ ¼ö ¾ø½À´Ï´Ù."));
308. else
309. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ½ºÅ³Àº ¾ÆÁ÷ ±×·£µå ¸¶½ºÅÍ ¼ö·ÃÀ» ÇÒ °æÁö¿¡ À̸£Áö ¾Ê¾Ò½À´Ï´Ù."));
310. return false;
311. }
313. std::string strTrainSkill;
314. {
315. std::ostringstream os;
316. os << "training_grandmaster_skill.skill" << dwSkillVnum;
317. strTrainSkill = os.str();
318. }
320. // ¿©±â¼­ È®·üÀ» °è»êÇÕ´Ï´Ù.
321. BYTE bLastLevel = GetSkillLevel(dwSkillVnum);
323. int idx = MIN(9, GetSkillLevel(dwSkillVnum) - 30);
325. sys_log(0, "LearnGrandMasterSkill %s table idx %d value %d", GetName(), idx, aiGrandMasterSkillBookCountForLevelUp[idx]);
327. int iTotalReadCount = GetQuestFlag(strTrainSkill) + 1;
328. SetQuestFlag(strTrainSkill, iTotalReadCount);
330. int iMinReadCount = aiGrandMasterSkillBookMinCount[idx];
331. int iMaxReadCount = aiGrandMasterSkillBookMaxCount[idx];
333. int iBookCount = aiGrandMasterSkillBookCountForLevelUp[idx];
335. if ( LC_IsYMIR() == true || LC_IsKorea() == true )
336. {
337. const int aiGrandMasterSkillBookCountForLevelUp_euckr[10] =
338. {
339. 3, 3, 4, 5, 6, 7, 8, 9, 10, 15,
340. };
342. const int aiGrandMasterSkillBookMinCount_euckr[10] =
343. {
344. 1, 1, 1, 2, 2, 2, 3, 3, 4, 5
345. };
347. const int aiGrandMasterSkillBookMaxCount_euckr[10] =
348. {
349. 5, 7, 9, 11, 13, 15, 18, 23, 25, 30
350. };
352. iMinReadCount = aiGrandMasterSkillBookMinCount_euckr[idx];
353. iMaxReadCount = aiGrandMasterSkillBookMaxCount_euckr[idx];
354. iBookCount = aiGrandMasterSkillBookCountForLevelUp_euckr[idx];
355. }
357. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
358. {
359. if (iBookCount&1)
360. iBookCount = iBookCount / 2 + 1;
361. else
362. iBookCount = iBookCount / 2;
364. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
365. }
367. int n = number(1, iBookCount);
368. sys_log(0, "Number(%d)", n);
370. DWORD nextTime = get_global_time() + number(28800, 43200);
372. sys_log(0, "GrandMaster SkillBookCount min %d cur %d max %d (next_time=%d)", iMinReadCount, iTotalReadCount, iMaxReadCount, nextTime);
374. bool bSuccess = n == 2;
376. if (iTotalReadCount < iMinReadCount)
377. bSuccess = false;
378. if (iTotalReadCount > iMaxReadCount)
379. bSuccess = true;
381. if (bSuccess)
382. {
383. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_QUEST);
384. }
386. SetSkillNextReadTime(dwSkillVnum, nextTime);
388. if (bLastLevel == GetSkillLevel(dwSkillVnum))
389. {
390. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("Å©À¹, ±â°¡ ¿ª·ùÇÏ°í ÀÖ¾î! ÀÌ°Å ¼³¸¶ ÁÖÈ­ÀÔ¸¶Àΰ¡!? Á¨Àå!"));
391. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÀÌ ½ÇÆзΠ³¡³µ½À´Ï´Ù. ´Ù½Ã µµÀüÇØÁֽñ⠹ٶø´Ï´Ù."));
392. LogManager::instance().CharLog(this, dwSkillVnum, "GM_READ_FAIL", "");
393. return false;
394. }
396. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸ö¿¡¼­ ¹º°¡ ÈûÀÌ ÅÍÁ® ³ª¿À´Â ±âºÐÀ̾ß!"));
397. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¶ß°Å¿î ¹«¾ùÀÌ °è¼Ó ¿ë¼ÚÀ½Ä¡°í ÀÖ¾î! ÀÌ°Ç, ÀÌ°ÍÀº!"));
398. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ³ôÀº °æÁöÀÇ ¼ö·ÃÀ» ¼º°øÀûÀ¸·Î ³¡³»¼Ì½À´Ï´Ù."));
399. LogManager::instance().CharLog(this, dwSkillVnum, "GM_READ_SUCCESS", "");
400. return true;
401. }
402. // END_OF_ADD_GRANDMASTER_SKILL
404. static bool FN_should_check_exp(LPCHARACTER ch)
405. {
406. if (LC_IsCanada())
407. return ch->GetLevel() < gPlayerMaxLevel;
409. if (!LC_IsYMIR())
410. return true;
412. return false;
413. }
416. bool CHARACTER::LearnSkillByBook(DWORD dwSkillVnum, BYTE bProb)
417. {
418. const CSkillProto* pkSk = CSkillManager::instance().Get(dwSkillVnum);
420. if (!pkSk)
421. return false;
423. if (!IsLearnableSkill(dwSkillVnum))
424. {
425. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÇÒ ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù."));
426. return false;
427. }
429. DWORD need_exp = 0;
431. if (FN_should_check_exp(this))
432. {
433. need_exp = 0;
435. if ( GetExp() < need_exp )
436. {
437. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°æÇèÄ¡°¡ ºÎÁ·ÇÏ¿© Ã¥À» ÀÐÀ» ¼ö ¾ø½À´Ï´Ù."));
438. return false;
439. }
440. }
442. // bTypeÀÌ 0À̸é óÀ½ºÎÅÍ Ã¥À¸·Î ¼ö·Ã °¡´É
443. if (pkSk->dwType != 0)
444. {
445. if (GetSkillMasterType(dwSkillVnum) != SKILL_MASTER)
446. {
447. if (GetSkillMasterType(dwSkillVnum) > SKILL_MASTER)
448. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ½ºÅ³Àº Ã¥À¸·Î ´õÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
449. else
450. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ½ºÅ³Àº ¾ÆÁ÷ Ã¥À¸·Î ¼ö·ÃÇÒ °æÁö¿¡ À̸£Áö ¾Ê¾Ò½À´Ï´Ù."));
451. return false;
452. }
453. }
455. if (get_global_time() < GetSkillNextReadTime(dwSkillVnum))
456. {
457. if (!(test_server && quest::CQuestManager::instance().GetEventFlag("no_read_delay")))
458. {
459. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
460. {
461. // Á־ȼú¼­ »ç¿ëÁß¿¡´Â ½Ã°£ Á¦ÇÑ ¹«½Ã
462. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
463. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á־ȼú¼­¸¦ ÅëÇØ ÁÖÈ­ÀÔ¸¶¿¡¼­ ºüÁ®³ª¿Ô½À´Ï´Ù."));
464. }
465. else
466. {
467. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
468. return false;
469. }
470. }
471. }
473. // ¿©±â¼­ È®·üÀ» °è»êÇÕ´Ï´Ù.
474. BYTE bLastLevel = GetSkillLevel(dwSkillVnum);
476. if (bProb != 0)
477. {
478. // SKILL_BOOK_BONUS
479. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
480. {
481. bProb += bProb / 2;
482. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
483. }
484. // END_OF_SKILL_BOOK_BONUS
486. sys_log(0, "LearnSkillByBook Pct %u prob %d", dwSkillVnum, bProb);
488. if (number(1, 100) <= bProb)
489. {
490. if (test_server)
491. sys_log(0, "LearnSkillByBook %u SUCC", dwSkillVnum);
493. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_BOOK);
494. }
495. else
496. {
497. if (test_server)
498. sys_log(0, "LearnSkillByBook %u FAIL", dwSkillVnum);
499. }
500. }
501. else
502. {
503. int idx = MIN(9, GetSkillLevel(dwSkillVnum) - 20);
505. sys_log(0, "LearnSkillByBook %s table idx %d value %d", GetName(), idx, aiSkillBookCountForLevelUp[idx]);
507. if (!LC_IsYMIR())
508. {
509. int need_bookcount = GetSkillLevel(dwSkillVnum) - 20;
511. PointChange(POINT_EXP, -need_exp);
513. quest::CQuestManager& q = quest::CQuestManager::instance();
514. quest::PC* pPC = q.GetPC(GetPlayerID());
516. if (pPC)
517. {
518. char flag[128+1];
519. memset(flag, 0, sizeof(flag));
520. snprintf(flag, sizeof(flag), "traning_master_skill.%u.read_count", dwSkillVnum);
522. int read_count = pPC->GetFlag(flag);
523. int percent = 65;
525. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
526. {
527. percent = 0;
528. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
529. }
531. if (number(1, 100) > percent)
532. {
533. // Ã¥Àб⿡ ¼º°ø
534. if (read_count >= need_bookcount)
535. {
536. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_BOOK);
537. pPC->SetFlag(flag, 0);
539. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ã¥À¸·Î ´õ ³ôÀº °æÁöÀÇ ¼ö·ÃÀ» ¼º°øÀûÀ¸·Î ³¡³»¼Ì½À´Ï´Ù."));
540. LogManager::instance().CharLog(this, dwSkillVnum, "READ_SUCCESS", "");
541. return true;
542. }
543. else
544. {
545. pPC->SetFlag(flag, read_count + 1);
547. switch (number(1, 3))
548. {
549. case 1:
550. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¾î´ÀÁ¤µµ ÀÌ ±â¼ú¿¡ ´ëÇØ ÀÌÇØ°¡ µÇ¾úÁö¸¸ Á¶±Ý ºÎÁ·Çѵí Çѵ¥.."));
551. break;
553. case 2:
554. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("µåµð¾î ³¡ÀÌ º¸ÀÌ´Â °Ç°¡... ÀÌ ±â¼úÀº ÀÌÇØÇϱⰡ ³Ê¹« Èûµé¾î.."));
555. break;
557. case 3:
558. default:
559. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¿­½ÉÈ÷ ÇÏ´Â ¹è¿òÀ» °¡Áö´Â °Í¸¸ÀÌ ±â¼úÀ» ¹è¿ï¼ö ÀÖ´Â À¯ÀÏÇÑ ±æÀÌ´Ù.."));
560. break;
561. }
563. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d ±ÇÀ» ´õ Àоî¾ß ¼ö·ÃÀ» ¿Ï·á ÇÒ ¼ö ÀÖ½À´Ï´Ù."), need_bookcount - read_count);
564. return true;
565. }
566. }
567. }
568. else
569. {
570. // »ç¿ëÀÚÀÇ Äù½ºÆ® Á¤º¸ ·Îµå ½ÇÆÐ
571. }
572. }
573. // INTERNATIONAL_VERSION
574. else
575. {
576. int iBookCount = 99;
578. if (LC_IsYMIR() == true)
579. {
580. const int aiSkillBookCountForLevelUp_euckr[10] =
581. {
582. 2, 2, 3, 3, 3, 3, 3, 3, 4, 5
583. };
585. iBookCount = aiSkillBookCountForLevelUp_euckr[idx];
586. }
587. else
588. iBookCount = aiSkillBookCountForLevelUp[idx];
590. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
591. {
592. if (iBookCount & 1) // iBookCount % 2
593. iBookCount = iBookCount / 2 + 1;
594. else
595. iBookCount = iBookCount / 2;
597. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
598. }
600. if (number(1, iBookCount) == 2)
601. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_BOOK);
602. }
603. // END_OF_INTERNATIONAL_VERSION
604. }
606. if (bLastLevel != GetSkillLevel(dwSkillVnum))
607. {
608. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸ö¿¡¼­ ¹º°¡ ÈûÀÌ ÅÍÁ® ³ª¿À´Â ±âºÐÀ̾ß!"));
609. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¶ß°Å¿î ¹«¾ùÀÌ °è¼Ó ¿ë¼ÚÀ½Ä¡°í ÀÖ¾î! ÀÌ°Ç, ÀÌ°ÍÀº!"));
610. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ã¥À¸·Î ´õ ³ôÀº °æÁöÀÇ ¼ö·ÃÀ» ¼º°øÀûÀ¸·Î ³¡³»¼Ì½À´Ï´Ù."));
611. LogManager::instance().CharLog(this, dwSkillVnum, "READ_SUCCESS", "");
612. }
613. else
614. {
615. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("Å©À¹, ±â°¡ ¿ª·ùÇÏ°í ÀÖ¾î! ÀÌ°Å ¼³¸¶ ÁÖÈ­ÀÔ¸¶Àΰ¡!? Á¨Àå!"));
616. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÀÌ ½ÇÆзΠ³¡³µ½À´Ï´Ù. ´Ù½Ã µµÀüÇØÁֽñ⠹ٶø´Ï´Ù."));
617. LogManager::instance().CharLog(this, dwSkillVnum, "READ_FAIL", "");
618. }
620. return true;
621. }
623. bool CHARACTER::SkillLevelDown(DWORD dwVnum)
624. {
625. if (NULL == m_pSkillLevels)
626. return false;
628. if (g_bSkillDisable)
629. return false;
631. if (IsPolymorphed())
632. return false;
634. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
636. if (!pkSk)
637. {
638. sys_err("There is no such skill by number %u", dwVnum);
639. return false;
640. }
642. if (!IsLearnableSkill(dwVnum))
643. return false;
645. if (GetSkillMasterType(pkSk->dwVnum) != SKILL_NORMAL)
646. return false;
648. if (!GetSkillGroup())
649. return false;
651. if (pkSk->dwVnum >= SKILL_MAX_NUM)
652. return false;
654. if (m_pSkillLevels[pkSk->dwVnum].bLevel == 0)
655. return false;
657. int idx = POINT_SKILL;
658. switch (pkSk->dwType)
659. {
660. case 0:
661. idx = POINT_SUB_SKILL;
662. break;
663. case 1:
664. case 2:
665. case 3:
666. case 4:
667. case 6:
668. idx = POINT_SKILL;
669. break;
670. case 5:
671. idx = POINT_HORSE_SKILL;
672. break;
673. default:
674. sys_err("Wrong skill type %d skill vnum %d", pkSk->dwType, pkSk->dwVnum);
675. return false;
677. }
679. PointChange(idx, +1);
680. SetSkillLevel(pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bLevel - 1);
682. sys_log(0, "SkillDown: %s %u %u %u type %u", GetName(), pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bMasterType, m_pSkillLevels[pkSk->dwVnum].bLevel, pkSk->dwType);
683. Save();
685. ComputePoints();
686. SkillLevelPacket();
687. return true;
688. }
690. void CHARACTER::SkillLevelUp(DWORD dwVnum, BYTE bMethod)
691. {
692. if (NULL == m_pSkillLevels)
693. return;
695. if (g_bSkillDisable)
696. return;
698. if (IsPolymorphed())
699. {
700. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µÐ°© Áß¿¡´Â ´É·ÂÀ» ¿Ã¸± ¼ö ¾ø½À´Ï´Ù."));
701. return;
702. }
704. if (SKILL_7_A_ANTI_TANHWAN <= dwVnum && dwVnum <= SKILL_8_D_ANTI_BYEURAK)
705. {
706. if (0 == GetSkillLevel(dwVnum))
707. return;
708. }
710. const CSkillProto* pkSk = CSkillManager::instance().Get(dwVnum);
712. if (!pkSk)
713. {
714. sys_err("There is no such skill by number (vnum %u)", dwVnum);
715. return;
716. }
718. if (pkSk->dwVnum >= SKILL_MAX_NUM)
719. {
720. sys_err("Skill Vnum overflow (vnum %u)", dwVnum);
721. return;
722. }
724. if (!IsLearnableSkill(dwVnum))
725. return;
727. // ±×·£µå ¸¶½ºÅÍ´Â Äù½ºÆ®·Î¸¸ ¼öÇà°¡´É
728. if (pkSk->dwType != 0)
729. {
730. switch (GetSkillMasterType(pkSk->dwVnum))
731. {
732. case SKILL_GRAND_MASTER:
733. if (bMethod != SKILL_UP_BY_QUEST)
734. return;
735. break;
737. case SKILL_PERFECT_MASTER:
738. return;
739. }
740. }
742. if (bMethod == SKILL_UP_BY_POINT)
743. {
744. // ¸¶½ºÅÍ°¡ ¾Æ´Ñ »óÅ¿¡¼­¸¸ ¼ö·Ã°¡´É
745. if (GetSkillMasterType(pkSk->dwVnum) != SKILL_NORMAL)
746. return;
748. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_DISABLE_BY_POINT_UP))
749. return;
750. }
751. else if (bMethod == SKILL_UP_BY_BOOK)
752. {
753. if (pkSk->dwType != 0) // Á÷¾÷¿¡ ¼ÓÇÏÁö ¾Ê¾Ò°Å³ª Æ÷ÀÎÆ®·Î ¿Ã¸±¼ö ¾ø´Â ½ºÅ³Àº óÀ½ºÎÅÍ Ã¥À¸·Î ¹è¿ï ¼ö ÀÖ´Ù.
754. if (GetSkillMasterType(pkSk->dwVnum) != SKILL_MASTER)
755. return;
756. }
758. if (GetLevel() < pkSk->bLevelLimit)
759. return;
761. if (pkSk->preSkillVnum)
762. if (GetSkillMasterType(pkSk->preSkillVnum) == SKILL_NORMAL &&
763. GetSkillLevel(pkSk->preSkillVnum) < pkSk->preSkillLevel)
764. return;
766. if (!GetSkillGroup())
767. return;
769. if (bMethod == SKILL_UP_BY_POINT)
770. {
771. int idx;
773. switch (pkSk->dwType)
774. {
775. case 0:
776. idx = POINT_SUB_SKILL;
777. break;
779. case 1:
780. case 2:
781. case 3:
782. case 4:
783. case 6:
784. idx = POINT_SKILL;
785. break;
787. case 5:
788. idx = POINT_HORSE_SKILL;
789. break;
791. default:
792. sys_err("Wrong skill type %d skill vnum %d", pkSk->dwType, pkSk->dwVnum);
793. return;
794. }
796. if (GetPoint(idx) < 1)
797. return;
799. PointChange(idx, -1);
800. }
802. int SkillPointBefore = GetSkillLevel(pkSk->dwVnum);
803. SetSkillLevel(pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bLevel + 1);
805. if (pkSk->dwType != 0)
806. {
807. // °©Àڱ⠱׷¹ÀÌµå ¾÷ÇÏ´Â ÄÚµù
808. switch (GetSkillMasterType(pkSk->dwVnum))
809. {
810. case SKILL_NORMAL:
812. // Skiller 17'de M Olsin
813. if (GetSkillLevel(pkSk->dwVnum) >= 17)
814. {
815. SetSkillLevel(pkSk->dwVnum, 20);
816. }
817. break;
819. case SKILL_MASTER:
820. if (GetSkillLevel(pkSk->dwVnum) >= 30)
821. {
822. if (number(1, 31 - MIN(30, GetSkillLevel(pkSk->dwVnum))) == 1)
823. SetSkillLevel(pkSk->dwVnum, 30);
824. }
825. break;
827. case SKILL_GRAND_MASTER:
828. if (GetSkillLevel(pkSk->dwVnum) >= 40)
829. {
830. SetSkillLevel(pkSk->dwVnum, 40);
831. }
832. break;
833. }
834. }
836. char szSkillUp[1024];
838. snprintf(szSkillUp, sizeof(szSkillUp), "SkillUp: %s %u %d %d[Before:%d] type %u",
839. GetName(), pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bMasterType, m_pSkillLevels[pkSk->dwVnum].bLevel, SkillPointBefore, pkSk->dwType);
841. sys_log(0, "%s", szSkillUp);
843. LogManager::instance().CharLog(this, pkSk->dwVnum, "SKILLUP", szSkillUp);
844. Save();
846. ComputePoints();
847. SkillLevelPacket();
848. }
850. void CHARACTER::ComputeSkillPoints()
851. {
852. if (g_bSkillDisable)
853. return;
854. }
856. void CHARACTER::ResetSkill()
857. {
858. if (NULL == m_pSkillLevels)
859. return;
861. // º¸Á¶ ½ºÅ³Àº ¸®¼Â½ÃÅ°Áö ¾Ê´Â´Ù
862. std::vector<std::pair<DWORD, TPlayerSkill> > vec;
863. size_t count = sizeof(s_adwSubSkillVnums) / sizeof(s_adwSubSkillVnums[0]);
865. for (size_t i = 0; i < count; ++i)
866. {
867. if (s_adwSubSkillVnums[i] >= SKILL_MAX_NUM)
868. continue;
870. vec.push_back(std::make_pair(s_adwSubSkillVnums[i], m_pSkillLevels[s_adwSubSkillVnums[i]]));
871. }
873. memset(m_pSkillLevels, 0, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
875. std::vector<std::pair<DWORD, TPlayerSkill> >::const_iterator iter = vec.begin();
877. while (iter != vec.end())
878. {
879. const std::pair<DWORD, TPlayerSkill>& pair = *(iter++);
880. m_pSkillLevels[pair.first] = pair.second;
881. }
883. ComputePoints();
884. SkillLevelPacket();
885. }
887. void CHARACTER::ComputePassiveSkill(DWORD dwVnum)
888. {
889. if (g_bSkillDisable)
890. return;
892. if (GetSkillLevel(dwVnum) == 0)
893. return;
895. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
896. pkSk->SetPointVar("k", GetSkillLevel(dwVnum));
897. int iAmount = (int) pkSk->kPointPoly.Eval();
899. sys_log(2, "%s passive #%d on %d amount %d", GetName(), dwVnum, pkSk->bPointOn, iAmount);
900. PointChange(pkSk->bPointOn, iAmount);
901. }
903. struct FFindNearVictim
904. {
905. FFindNearVictim(LPCHARACTER center, LPCHARACTER attacker, const CHARACTER_SET& excepts_set = empty_set_)
906. : m_pkChrCenter(center),
907. m_pkChrNextTarget(NULL),
908. m_pkChrAttacker(attacker),
909. m_count(0),
910. m_excepts_set(excepts_set)
911. {
912. }
914. void operator ()(LPENTITY ent)
915. {
916. if (!ent->IsType(ENTITY_CHARACTER))
917. return;
919. LPCHARACTER pkChr = (LPCHARACTER) ent;
921. if (!m_excepts_set.empty()) {
922. if (m_excepts_set.find(pkChr) != m_excepts_set.end())
923. return;
924. }
926. if (m_pkChrCenter == pkChr)
927. return;
929. if (!battle_is_attackable(m_pkChrAttacker, pkChr))
930. {
931. return;
932. }
934. if (abs(m_pkChrCenter->GetX() - pkChr->GetX()) > 1000 || abs(m_pkChrCenter->GetY() - pkChr->GetY()) > 1000)
935. return;
937. float fDist = DISTANCE_APPROX(m_pkChrCenter->GetX() - pkChr->GetX(), m_pkChrCenter->GetY() - pkChr->GetY());
939. if (fDist < 1000)
940. {
941. ++m_count;
943. if ((m_count == 1) || number(1, m_count) == 1)
944. m_pkChrNextTarget = pkChr;
945. }
946. }
948. LPCHARACTER GetVictim()
949. {
950. return m_pkChrNextTarget;
951. }
953. LPCHARACTER m_pkChrCenter;
954. LPCHARACTER m_pkChrNextTarget;
955. LPCHARACTER m_pkChrAttacker;
956. int m_count;
957. const CHARACTER_SET & m_excepts_set;
958. private:
959. static CHARACTER_SET empty_set_;
960. };
962. CHARACTER_SET FFindNearVictim::empty_set_;
964. EVENTINFO(chain_lightning_event_info)
965. {
966. DWORD dwVictim;
967. DWORD dwChr;
969. chain_lightning_event_info()
970. : dwVictim(0)
971. , dwChr(0)
972. {
973. }
974. };
976. EVENTFUNC(ChainLightningEvent)
977. {
978. chain_lightning_event_info * info = dynamic_cast<chain_lightning_event_info *>( event->info );
980. LPCHARACTER pkChrVictim = CHARACTER_MANAGER::instance().Find(info->dwVictim);
981. LPCHARACTER pkChr = CHARACTER_MANAGER::instance().Find(info->dwChr);
982. LPCHARACTER pkTarget = NULL;
984. if (!pkChr || !pkChrVictim)
985. {
986. sys_log(1, "use chainlighting, but no character");
987. return 0;
988. }
990. sys_log(1, "chainlighting event %s", pkChr->GetName());
992. if (pkChrVictim->GetParty()) // ÆÄƼ ¸ÕÀú
993. {
994. pkTarget = pkChrVictim->GetParty()->GetNextOwnership(NULL, pkChrVictim->GetX(), pkChrVictim->GetY());
995. if (pkTarget == pkChrVictim || !number(0, 2) || pkChr->GetChainLightingExcept().find(pkTarget) != pkChr->GetChainLightingExcept().end())
996. pkTarget = NULL;
997. }
999. if (!pkTarget)
1000. {
1001. // 1. Find Next victim
1002. FFindNearVictim f(pkChrVictim, pkChr, pkChr->GetChainLightingExcept());
1004. if (pkChrVictim->GetSectree())
1005. {
1006. pkChrVictim->GetSectree()->ForEachAround(f);
1007. // 2. If exist, compute it again
1008. pkTarget = f.GetVictim();
1009. }
1010. }
1012. if (pkTarget)
1013. {
1014. pkChrVictim->CreateFly(FLY_CHAIN_LIGHTNING, pkTarget);
1015. pkChr->ComputeSkill(SKILL_CHAIN, pkTarget);
1016. pkChr->AddChainLightningExcept(pkTarget);
1017. }
1018. else
1019. {
1020. sys_log(1, "%s use chainlighting, but find victim failed near %s", pkChr->GetName(), pkChrVictim->GetName());
1021. }
1023. return 0;
1024. }
1026. void SetPolyVarForAttack(LPCHARACTER ch, CSkillProto * pkSk, LPITEM pkWeapon)
1027. {
1028. if (ch->IsPC())
1029. {
1030. if (pkWeapon && pkWeapon->GetType() == ITEM_WEAPON)
1031. {
1032. int iWep = number(pkWeapon->GetValue(3), pkWeapon->GetValue(4));
1033. iWep += pkWeapon->GetValue(5);
1035. int iMtk = number(pkWeapon->GetValue(1), pkWeapon->GetValue(2));
1036. iMtk += pkWeapon->GetValue(5);
1038. pkSk->SetPointVar("wep", iWep);
1039. pkSk->SetPointVar("mtk", iMtk);
1040. pkSk->SetPointVar("mwep", iMtk);
1041. }
1042. else
1043. {
1044. pkSk->SetPointVar("wep", 0);
1045. pkSk->SetPointVar("mtk", 0);
1046. pkSk->SetPointVar("mwep", 0);
1047. }
1048. }
1049. else
1050. {
1051. int iWep = number(ch->GetMobDamageMin(), ch->GetMobDamageMax());
1052. pkSk->SetPointVar("wep", iWep);
1053. pkSk->SetPointVar("mwep", iWep);
1054. pkSk->SetPointVar("mtk", iWep);
1055. }
1056. }
1058. struct FuncSplashDamage
1059. {
1060. FuncSplashDamage(int x, int y, CSkillProto * pkSk, LPCHARACTER pkChr, int iAmount, int iAG, int iMaxHit, LPITEM pkWeapon, bool bDisableCooltime, TSkillUseInfo* pInfo, BYTE bUseSkillPower)
1061. :
1062. m_x(x), m_y(y), m_pkSk(pkSk), m_pkChr(pkChr), m_iAmount(iAmount), m_iAG(iAG), m_iCount(0), m_iMaxHit(iMaxHit), m_pkWeapon(pkWeapon), m_bDisableCooltime(bDisableCooltime), m_pInfo(pInfo), m_bUseSkillPower(bUseSkillPower)
1063. {
1064. }
1066. void operator () (LPENTITY ent)
1067. {
1068. if (!ent->IsType(ENTITY_CHARACTER))
1069. {
1070. //if (m_pkSk->dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN target not character %s", m_pkChr->GetName());
1071. return;
1072. }
1074. LPCHARACTER pkChrVictim = (LPCHARACTER) ent;
1076. if (DISTANCE_APPROX(m_x - pkChrVictim->GetX(), m_y - pkChrVictim->GetY()) > m_pkSk->iSplashRange)
1077. {
1078. if(test_server)
1079. sys_log(0, "XXX target too far %s", m_pkChr->GetName());
1080. return;
1081. }
1083. if (!battle_is_attackable(m_pkChr, pkChrVictim))
1084. {
1085. if(test_server)
1086. sys_log(0, "XXX target not attackable %s", m_pkChr->GetName());
1087. return;
1088. }
1090. if (m_pkChr->IsPC())
1091. // ±æµå ½ºÅ³Àº ÄðŸÀÓ Ã³¸®¸¦ ÇÏÁö ¾Ê´Â´Ù.
1092. if (!(m_pkSk->dwVnum >= GUILD_SKILL_START && m_pkSk->dwVnum <= GUILD_SKILL_END))
1093. if (!m_bDisableCooltime && m_pInfo && !m_pInfo->HitOnce(m_pkSk->dwVnum) && m_pkSk->dwVnum != SKILL_MUYEONG)
1094. {
1095. if(test_server)
1096. sys_log(0, "check guild skill %s", m_pkChr->GetName());
1097. return;
1098. }
1100. ++m_iCount;
1102. int iDam;
1104. ////////////////////////////////////////////////////////////////////////////////
1105. //float k = 1.0f * m_pkChr->GetSkillPower(m_pkSk->dwVnum) * m_pkSk->bMaxLevel / 100;
1106. //m_pkSk->kPointPoly2.SetVar("k", 1.0 * m_bUseSkillPower * m_pkSk->bMaxLevel / 100);
1107. m_pkSk->SetPointVar("k", 1.0 * m_bUseSkillPower * m_pkSk->bMaxLevel / 100);
1108. m_pkSk->SetPointVar("lv", m_pkChr->GetLevel());
1109. m_pkSk->SetPointVar("iq", m_pkChr->GetPoint(POINT_IQ));
1110. m_pkSk->SetPointVar("str", m_pkChr->GetPoint(POINT_ST));
1111. m_pkSk->SetPointVar("dex", m_pkChr->GetPoint(POINT_DX));
1112. m_pkSk->SetPointVar("con", m_pkChr->GetPoint(POINT_HT));
1113. m_pkSk->SetPointVar("def", m_pkChr->GetPoint(POINT_DEF_GRADE));
1114. m_pkSk->SetPointVar("odef", m_pkChr->GetPoint(POINT_DEF_GRADE) - m_pkChr->GetPoint(POINT_DEF_GRADE_BONUS));
1115. m_pkSk->SetPointVar("horse_level", m_pkChr->GetHorseLevel());
1117. //int iPenetratePct = (int)(1 + k*4);
1118. bool bIgnoreDefense = false;
1120. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_PENETRATE))
1121. {
1122. int iPenetratePct = (int) m_pkSk->kPointPoly2.Eval();
1124. if (number(1, 100) <= iPenetratePct)
1125. bIgnoreDefense = true;
1126. }
1128. bool bIgnoreTargetRating = false;
1130. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_IGNORE_TARGET_RATING))
1131. {
1132. int iPct = (int) m_pkSk->kPointPoly2.Eval();
1134. if (number(1, 100) <= iPct)
1135. bIgnoreTargetRating = true;
1136. }
1138. m_pkSk->SetPointVar("ar", CalcAttackRating(m_pkChr, pkChrVictim, bIgnoreTargetRating));
1140. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_USE_MELEE_DAMAGE))
1141. m_pkSk->SetPointVar("atk", CalcMeleeDamage(m_pkChr, pkChrVictim, true, bIgnoreTargetRating));
1142. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_USE_ARROW_DAMAGE))
1143. {
1144. LPITEM pkBow, pkArrow;
1146. if (1 == m_pkChr->GetArrowAndBow(&pkBow, &pkArrow, 1))
1147. m_pkSk->SetPointVar("atk", CalcArrowDamage(m_pkChr, pkChrVictim, pkBow, pkArrow, true));
1148. else
1149. m_pkSk->SetPointVar("atk", 0);
1150. }
1152. if (m_pkSk->bPointOn == POINT_MOV_SPEED)
1153. m_pkSk->kPointPoly.SetVar("maxv", pkChrVictim->GetLimitPoint(POINT_MOV_SPEED));
1155. m_pkSk->SetPointVar("maxhp", pkChrVictim->GetMaxHP());
1156. m_pkSk->SetPointVar("maxsp", pkChrVictim->GetMaxSP());
1158. m_pkSk->SetPointVar("chain", m_pkChr->GetChainLightningIndex());
1159. m_pkChr->IncChainLightningIndex();
1161. bool bUnderEunhyung = m_pkChr->GetAffectedEunhyung() > 0; // ÀÌ°Ç ¿Ö ¿©±â¼­ ÇÏÁö??
1163. m_pkSk->SetPointVar("ek", m_pkChr->GetAffectedEunhyung()*1./100);
1164. //m_pkChr->ClearAffectedEunhyung();
1165. SetPolyVarForAttack(m_pkChr, m_pkSk, m_pkWeapon);
1167. int iAmount = 0;
1169. if (m_pkChr->GetUsedSkillMasterType(m_pkSk->dwVnum) >= SKILL_GRAND_MASTER)
1170. {
1171. iAmount = (int) m_pkSk->kMasterBonusPoly.Eval();
1172. }
1173. else
1174. {
1175. iAmount = (int) m_pkSk->kPointPoly.Eval();
1176. }
1178. if (test_server && iAmount == 0 && m_pkSk->bPointOn != POINT_NONE)
1179. {
1180. m_pkChr->ChatPacket(CHAT_TYPE_INFO, "È¿°ú°¡ ¾ø½À´Ï´Ù. ½ºÅ³ °ø½ÄÀ» È®ÀÎÇϼ¼¿ä");
1181. }
1182. ////////////////////////////////////////////////////////////////////////////////
1183. iAmount = -iAmount;
1185. if (m_pkSk->dwVnum == SKILL_AMSEOP)
1186. {
1187. float fDelta = GetDegreeDelta(m_pkChr->GetRotation(), pkChrVictim->GetRotation());
1188. float adjust;
1190. if (fDelta < 35.0f)
1191. {
1192. adjust = 1.5f;
1194. if (bUnderEunhyung)
1195. adjust += 0.5f;
1197. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
1198. {
1199. //if (!g_iUseLocale)
1200. if ( LC_IsYMIR() )
1201. adjust += 1.0f;
1202. else
1203. adjust += 0.5f;
1204. }
1205. }
1206. else
1207. {
1208. adjust = 1.0f;
1210. if ( !LC_IsYMIR() )
1211. {
1212. if (bUnderEunhyung)
1213. adjust += 0.5f;
1215. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
1216. adjust += 0.5f;
1217. }
1218. }
1220. iAmount = (int) (iAmount * adjust);
1221. }
1222. else if (m_pkSk->dwVnum == SKILL_GUNGSIN)
1223. {
1224. float adjust = 1.0;
1226. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
1227. {
1228. //if (!g_iUseLocale)
1229. if ( LC_IsYMIR() )
1230. adjust = 1.4f;
1231. else
1232. adjust = 1.35f;
1233. }
1235. iAmount = (int) (iAmount * adjust);
1236. }
1237. ////////////////////////////////////////////////////////////////////////////////
1238. //sys_log(0, "name: %s skill: %s amount %d to %s", m_pkChr->GetName(), m_pkSk->szName, iAmount, pkChrVictim->GetName());
1240. iDam = CalcBattleDamage(iAmount, m_pkChr->GetLevel(), pkChrVictim->GetLevel());
1242. if (m_pkChr->IsPC() && m_pkChr->m_SkillUseInfo[m_pkSk->dwVnum].GetMainTargetVID() != (DWORD) pkChrVictim->GetVID())
1243. {
1244. // µ¥¹ÌÁö °¨¼Ò
1245. iDam = (int) (iDam * m_pkSk->kSplashAroundDamageAdjustPoly.Eval());
1246. }
1248. // TODO ½ºÅ³¿¡ µû¸¥ µ¥¹ÌÁö ŸÀÔ ±â·ÏÇؾßÇÑ´Ù.
1249. EDamageType dt = DAMAGE_TYPE_NONE;
1251. switch (m_pkSk->bSkillAttrType)
1252. {
1253. case SKILL_ATTR_TYPE_NORMAL:
1254. break;
1256. case SKILL_ATTR_TYPE_MELEE:
1257. {
1258. dt = DAMAGE_TYPE_MELEE;
1260. LPITEM pkWeapon = m_pkChr->GetWear(WEAR_WEAPON);
1262. if (pkWeapon)
1263. switch (pkWeapon->GetSubType())
1264. {
1265. case WEAPON_SWORD:
1266. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_SWORD)) / 100;
1267. break;
1269. case WEAPON_TWO_HANDED:
1270. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_TWOHAND)) / 100;
1271. // ¾ç¼Õ°Ë Æä³ÎƼ 10%
1272. //iDam = iDam * 95 / 100;
1274. break;
1276. case WEAPON_DAGGER:
1277. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_DAGGER)) / 100;
1278. break;
1280. case WEAPON_BELL:
1281. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_BELL)) / 100;
1282. break;
1284. case WEAPON_FAN:
1285. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_FAN)) / 100;
1286. break;
1287. }
1289. if (!bIgnoreDefense)
1290. iDam -= pkChrVictim->GetPoint(POINT_DEF_GRADE);
1291. }
1292. break;
1294. case SKILL_ATTR_TYPE_RANGE:
1295. dt = DAMAGE_TYPE_RANGE;
1296. // À¸¾Æ¾Æ¾Æ¾Ç
1297. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
1298. //iDam -= pkChrVictim->GetPoint(POINT_DEF_GRADE);
1299. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_BOW)) / 100;
1300. break;
1302. case SKILL_ATTR_TYPE_MAGIC:
1303. dt = DAMAGE_TYPE_MAGIC;
1304. iDam = CalcAttBonus(m_pkChr, pkChrVictim, iDam);
1305. // À¸¾Æ¾Æ¾Æ¾Ç
1306. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
1307. //iDam -= pkChrVictim->GetPoint(POINT_MAGIC_DEF_GRADE);
1308. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_MAGIC)) / 100;
1309. break;
1311. case SKILL_ATTR_TYPE_FIRE:
1312. dt = DAMAGE_TYPE_MAGIC;
1313. iDam = CalcAttBonus(m_pkChr, pkChrVictim, iDam);
1314. // À¸¾Æ¾Æ¾Æ¾Ç
1315. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
1316. //iDam -= pkChrVictim->GetPoint(POINT_MAGIC_DEF_GRADE);
1317. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_FIRE)) / 100;
1318. break;
1320. case SKILL_ATTR_TYPE_ICE:
1321. dt = DAMAGE_TYPE_MAGIC;
1322. iDam = CalcAttBonus(m_pkChr, pkChrVictim, iDam);
1323. // À¸¾Æ¾Æ¾Æ¾Ç
1324. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
1325. //iDam -= pkChrVictim->GetPoint(POINT_MAGIC_DEF_GRADE);
1326. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_ICE)) / 100;
1327. break;
1329. case SKILL_ATTR_TYPE_ELEC:
1330. dt = DAMAGE_TYPE_MAGIC;
1331. iDam = CalcAttBonus(m_pkChr, pkChrVictim, iDam);
1332. // À¸¾Æ¾Æ¾Æ¾Ç
1333. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
1334. //iDam -= pkChrVictim->GetPoint(POINT_MAGIC_DEF_GRADE);
1335. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_ELEC)) / 100;
1336. break;
1338. case SKILL_ATTR_TYPE_DARK:
1339. dt = DAMAGE_TYPE_MAGIC;
1340. iDam = CalcAttBonus(m_pkChr, pkChrVictim, iDam);
1341. // À¸¾Æ¾Æ¾Æ¾Ç
1342. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
1343. //iDam -= pkChrVictim->GetPoint(POINT_MAGIC_DEF_GRADE);
1344. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_DARK)) / 100;
1345. break;
1347. default:
1348. sys_err("Unknown skill attr type %u vnum %u", m_pkSk->bSkillAttrType, m_pkSk->dwVnum);
1349. break;
1350. }
1352. //
1353. // 20091109 µ¶ÀÏ ½ºÅ³ ¼Ó¼º ¿äû ÀÛ¾÷
1354. // ±âÁ¸ ½ºÅ³ Å×ÀÌºí¿¡ SKILL_FLAG_WIND, SKILL_FLAG_ELEC, SKILL_FLAG_FIRE¸¦ °¡Áø ½ºÅ³ÀÌ
1355. // ÀüÇô ¾ø¾úÀ¸¹Ç·Î ¸ó½ºÅÍÀÇ RESIST_WIND, RESIST_ELEC, RESIST_FIREµµ »ç¿ëµÇÁö ¾Ê°í ÀÖ¾ú´Ù.
1356. //
1357. // PvP¿Í PvE¹ë·±½º ºÐ¸®¸¦ À§ÇØ ÀǵµÀûÀ¸·Î NPC¸¸ Àû¿ëÇϵµ·Ï ÇßÀ¸¸ç ±âÁ¸ ¹ë·±½º¿Í Â÷ÀÌÁ¡À»
1358. // ´À³¢Áö ¸øÇϱâ À§ÇØ mob_protoÀÇ RESIST_MAGICÀ» RESIST_WIND, RESIST_ELEC, RESIST_FIRE·Î
1359. // º¹»çÇÏ¿´´Ù.
1360. //
1361. if (pkChrVictim->IsNPC())
1362. {
1363. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_WIND))
1364. {
1365. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_WIND)) / 100;
1366. }
1368. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_ELEC))
1369. {
1370. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_ELEC)) / 100;
1371. }
1373. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_FIRE))
1374. {
1375. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_FIRE)) / 100;
1376. }
1377. }
1379. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_COMPUTE_MAGIC_DAMAGE))
1380. dt = DAMAGE_TYPE_MAGIC;
1382. if (pkChrVictim->CanBeginFight())
1383. pkChrVictim->BeginFight(m_pkChr);
1385. if (m_pkSk->dwVnum == SKILL_CHAIN)
1386. sys_log(0, "%s CHAIN INDEX %d DAM %d DT %d", m_pkChr->GetName(), m_pkChr->GetChainLightningIndex() - 1, iDam, dt);
1388. {
1389. BYTE AntiSkillID = 0;
1391. switch (m_pkSk->dwVnum)
1392. {
1393. case SKILL_TANHWAN: AntiSkillID = SKILL_7_A_ANTI_TANHWAN; break;
1394. case SKILL_AMSEOP: AntiSkillID = SKILL_7_B_ANTI_AMSEOP; break;
1395. case SKILL_SWAERYUNG: AntiSkillID = SKILL_7_C_ANTI_SWAERYUNG; break;
1396. case SKILL_YONGBI: AntiSkillID = SKILL_7_D_ANTI_YONGBI; break;
1397. case SKILL_GIGONGCHAM: AntiSkillID = SKILL_8_A_ANTI_GIGONGCHAM; break;
1398. case SKILL_YEONSA: AntiSkillID = SKILL_8_B_ANTI_YEONSA; break;
1399. case SKILL_MAHWAN: AntiSkillID = SKILL_8_C_ANTI_MAHWAN; break;
1400. case SKILL_BYEURAK: AntiSkillID = SKILL_8_D_ANTI_BYEURAK; break;
1401. }
1403. if (0 != AntiSkillID)
1404. {
1405. BYTE AntiSkillLevel = pkChrVictim->GetSkillLevel(AntiSkillID);
1407. if (0 != AntiSkillLevel)
1408. {
1409. CSkillProto* pkSk = CSkillManager::instance().Get(AntiSkillID);
1410. if (!pkSk)
1411. {
1412. sys_err ("There is no anti skill(%d) in skill proto", AntiSkillID);
1413. }
1414. else
1415. {
1416. pkSk->SetPointVar("k", 1.0f * pkChrVictim->GetSkillPower(AntiSkillID) * pkSk->bMaxLevel / 100);
1418. double ResistAmount = pkSk->kPointPoly.Eval();
1420. sys_log(0, "ANTI_SKILL: Resist(%lf) Orig(%d) Reduce(%d)", ResistAmount, iDam, int(iDam * (ResistAmount/100.0)));
1422. iDam -= iDam * (ResistAmount/100.0);
1423. }
1424. }
1425. }
1426. }
1428. if (!pkChrVictim->Damage(m_pkChr, iDam, dt) && !pkChrVictim->IsStun())
1429. {
1430. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_REMOVE_GOOD_AFFECT))
1431. {
1432. int iAmount2 = (int) m_pkSk->kPointPoly2.Eval();
1433. int iDur2 = (int) m_pkSk->kDurationPoly2.Eval();
1434. iDur2 += m_pkChr->GetPoint(POINT_PARTY_BUFFER_BONUS);
1436. if (number(1, 100) <= iAmount2)
1437. {
1438. pkChrVictim->RemoveGoodAffect();
1439. pkChrVictim->AddAffect(m_pkSk->dwVnum, POINT_NONE, 0, AFF_PABEOP, iDur2, 0, true);
1440. }
1441. }
1443. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SLOW | SKILL_FLAG_STUN | SKILL_FLAG_FIRE_CONT | SKILL_FLAG_POISON))
1444. {
1445. int iPct = (int) m_pkSk->kPointPoly2.Eval();
1446. int iDur = (int) m_pkSk->kDurationPoly2.Eval();
1448. iDur += m_pkChr->GetPoint(POINT_PARTY_BUFFER_BONUS);
1450. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_STUN))
1451. {
1452. SkillAttackAffect(pkChrVictim, iPct, IMMUNE_STUN, AFFECT_STUN, POINT_NONE, 0, AFF_STUN, iDur, m_pkSk->szName);
1453. }
1454. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SLOW))
1455. {
1456. SkillAttackAffect(pkChrVictim, iPct, IMMUNE_SLOW, AFFECT_SLOW, POINT_MOV_SPEED, -30, AFF_SLOW, iDur, m_pkSk->szName);
1457. }
1458. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_FIRE_CONT))
1459. {
1460. m_pkSk->SetDurationVar("k", 1.0 * m_bUseSkillPower * m_pkSk->bMaxLevel / 100);
1461. m_pkSk->SetDurationVar("iq", m_pkChr->GetPoint(POINT_IQ));
1463. iDur = (int)m_pkSk->kDurationPoly2.Eval();
1464. int bonus = m_pkChr->GetPoint(POINT_PARTY_BUFFER_BONUS);
1466. if (bonus != 0)
1467. {
1468. iDur += bonus / 2;
1469. }
1471. if (number(1, 100) <= iDur)
1472. {
1473. pkChrVictim->AttackedByFire(m_pkChr, iPct, 5);
1474. }
1475. }
1476. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_POISON))
1477. {
1478. if (number(1, 100) <= iPct)
1479. pkChrVictim->AttackedByPoison(m_pkChr);
1480. }
1481. }
1483. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_CRUSH | SKILL_FLAG_CRUSH_LONG) &&
1484. !IS_SET(pkChrVictim->GetAIFlag(), AIFLAG_NOMOVE))
1485. {
1486. float fCrushSlidingLength = 200;
1488. if (m_pkChr->IsNPC())
1489. fCrushSlidingLength = 400;
1491. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_CRUSH_LONG))
1492. fCrushSlidingLength *= 2;
1494. float fx, fy;
1495. float degree = GetDegreeFromPositionXY(m_pkChr->GetX(), m_pkChr->GetY(), pkChrVictim->GetX(), pkChrVictim->GetY());
1497. if (m_pkSk->dwVnum == SKILL_HORSE_WILDATTACK)
1498. {
1499. degree -= m_pkChr->GetRotation();
1500. degree = fmod(degree, 360.0f) - 180.0f;
1502. if (degree > 0)
1503. degree = m_pkChr->GetRotation() + 90.0f;
1504. else
1505. degree = m_pkChr->GetRotation() - 90.0f;
1506. }
1508. GetDeltaByDegree(degree, fCrushSlidingLength, &fx, &fy);
1509. sys_log(0, "CRUSH! %s -> %s (%d %d) -> (%d %d)", m_pkChr->GetName(), pkChrVictim->GetName(), pkChrVictim->GetX(), pkChrVictim->GetY(), (long)(pkChrVictim->GetX()+fx), (long)(pkChrVictim->GetY()+fy));
1510. long tx = (long)(pkChrVictim->GetX()+fx);
1511. long ty = (long)(pkChrVictim->GetY()+fy);
1513. pkChrVictim->Sync(tx, ty);
1514. pkChrVictim->Goto(tx, ty);
1515. pkChrVictim->CalculateMoveDuration();
1517. if (m_pkChr->IsPC() && m_pkChr->m_SkillUseInfo[m_pkSk->dwVnum].GetMainTargetVID() == (DWORD) pkChrVictim->GetVID())
1518. {
1519. //if (!g_iUseLocale)
1520. if (LC_IsYMIR())
1521. SkillAttackAffect(pkChrVictim, 1000, IMMUNE_STUN, m_pkSk->dwVnum, POINT_NONE, 0, AFF_STUN, 3, m_pkSk->szName);
1522. else
1523. SkillAttackAffect(pkChrVictim, 1000, IMMUNE_STUN, m_pkSk->dwVnum, POINT_NONE, 0, AFF_STUN, 4, m_pkSk->szName);
1524. }
1525. else
1526. {
1527. pkChrVictim->SyncPacket();
1528. }
1529. }
1530. }
1532. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_HP_ABSORB))
1533. {
1534. int iPct = (int) m_pkSk->kPointPoly2.Eval();
1535. m_pkChr->PointChange(POINT_HP, iDam * iPct / 100);
1536. }
1538. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SP_ABSORB))
1539. {
1540. int iPct = (int) m_pkSk->kPointPoly2.Eval();
1541. m_pkChr->PointChange(POINT_SP, iDam * iPct / 100);
1542. }
1544. if (m_pkSk->dwVnum == SKILL_CHAIN && m_pkChr->GetChainLightningIndex() < m_pkChr->GetChainLightningMaxCount())
1545. {
1546. chain_lightning_event_info* info = AllocEventInfo<chain_lightning_event_info>();
1548. info->dwVictim = pkChrVictim->GetVID();
1549. info->dwChr = m_pkChr->GetVID();
1551. event_create(ChainLightningEvent, info, passes_per_sec / 5);
1552. }
1553. if(test_server)
1554. sys_log(0, "FuncSplashDamage End :%s ", m_pkChr->GetName());
1555. }
1557. int m_x;
1558. int m_y;
1559. CSkillProto * m_pkSk;
1560. LPCHARACTER m_pkChr;
1561. int m_iAmount;
1562. int m_iAG;
1563. int m_iCount;
1564. int m_iMaxHit;
1565. LPITEM m_pkWeapon;
1566. bool m_bDisableCooltime;
1567. TSkillUseInfo* m_pInfo;
1568. BYTE m_bUseSkillPower;
1569. };
1571. struct FuncSplashAffect
1572. {
1573. FuncSplashAffect(LPCHARACTER ch, int x, int y, int iDist, DWORD dwVnum, BYTE bPointOn, int iAmount, DWORD dwAffectFlag, int iDuration, int iSPCost, bool bOverride, int iMaxHit)
1574. {
1575. m_x = x;
1576. m_y = y;
1577. m_iDist = iDist;
1578. m_dwVnum = dwVnum;
1579. m_bPointOn = bPointOn;
1580. m_iAmount = iAmount;
1581. m_dwAffectFlag = dwAffectFlag;
1582. m_iDuration = iDuration;
1583. m_iSPCost = iSPCost;
1584. m_bOverride = bOverride;
1585. m_pkChrAttacker = ch;
1586. m_iMaxHit = iMaxHit;
1587. m_iCount = 0;
1588. }
1590. void operator () (LPENTITY ent)
1591. {
1592. if (m_iMaxHit && m_iMaxHit <= m_iCount)
1593. return;
1595. if (ent->IsType(ENTITY_CHARACTER))
1596. {
1597. LPCHARACTER pkChr = (LPCHARACTER) ent;
1599. if (test_server)
1600. sys_log(0, "FuncSplashAffect step 1 : name:%s vnum:%d iDur:%d", pkChr->GetName(), m_dwVnum, m_iDuration);
1601. if (DISTANCE_APPROX(m_x - pkChr->GetX(), m_y - pkChr->GetY()) < m_iDist)
1602. {
1603. if (test_server)
1604. sys_log(0, "FuncSplashAffect step 2 : name:%s vnum:%d iDur:%d", pkChr->GetName(), m_dwVnum, m_iDuration);
1605. if (m_dwVnum == SKILL_TUSOK)
1606. if (pkChr->CanBeginFight())
1607. pkChr->BeginFight(m_pkChrAttacker);
1609. if (pkChr->IsPC() && m_dwVnum == SKILL_TUSOK)
1610. pkChr->AddAffect(m_dwVnum, m_bPointOn, m_iAmount, m_dwAffectFlag, m_iDuration/3, m_iSPCost, m_bOverride);
1611. else
1612. pkChr->AddAffect(m_dwVnum, m_bPointOn, m_iAmount, m_dwAffectFlag, m_iDuration, m_iSPCost, m_bOverride);
1614. m_iCount ++;
1615. }
1616. }
1617. }
1619. LPCHARACTER m_pkChrAttacker;
1620. int m_x;
1621. int m_y;
1622. int m_iDist;
1623. DWORD m_dwVnum;
1624. BYTE m_bPointOn;
1625. int m_iAmount;
1626. DWORD m_dwAffectFlag;
1627. int m_iDuration;
1628. int m_iSPCost;
1629. bool m_bOverride;
1630. int m_iMaxHit;
1631. int m_iCount;
1632. };
1634. EVENTINFO(skill_gwihwan_info)
1635. {
1636. DWORD pid;
1637. BYTE bsklv;
1639. skill_gwihwan_info()
1640. : pid( 0 )
1641. , bsklv( 0 )
1642. {
1643. }
1644. };
1646. EVENTFUNC(skill_gwihwan_event)
1647. {
1648. skill_gwihwan_info* info = dynamic_cast<skill_gwihwan_info*>( event->info );
1650. if ( info == NULL )
1651. {
1652. sys_err( "skill_gwihwan_event> <Factor> Null pointer" );
1653. return 0;
1654. }
1656. DWORD pid = info->pid;
1657. BYTE sklv= info->bsklv;
1658. LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(pid);
1660. if (!ch)
1661. return 0;
1663. int percent = 20 * sklv - 1;
1665. if (number(1, 100) <= percent)
1666. {
1667. PIXEL_POSITION pos;
1669. // ¼º°ø
1670. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(ch->GetMapIndex(), ch->GetEmpire(), pos))
1671. {
1672. sys_log(1, "Recall: %s %d %d -> %d %d", ch->GetName(), ch->GetX(), ch->GetY(), pos.x, pos.y);
1673. ch->WarpSet(pos.x, pos.y);
1674. }
1675. else
1676. {
1677. sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", ch->GetName(), ch->GetX(), ch->GetY());
1678. ch->WarpSet(EMPIRE_START_X(ch->GetEmpire()), EMPIRE_START_Y(ch->GetEmpire()));
1679. }
1680. }
1681. else
1682. {
1683. //½ÇÆÐ
1684. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±Íȯ¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
1685. }
1686. return 0;
1687. }
1689. int CHARACTER::ComputeSkillAtPosition(DWORD dwVnum, const PIXEL_POSITION& posTarget, BYTE bSkillLevel)
1690. {
1691. if (GetMountVnum())
1692. return BATTLE_NONE;
1694. if (IsPolymorphed())
1695. return BATTLE_NONE;
1697. if (g_bSkillDisable)
1698. return BATTLE_NONE;
1700. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
1702. if (!pkSk)
1703. return BATTLE_NONE;
1705. if (test_server)
1706. {
1707. sys_log(0, "ComputeSkillAtPosition %s vnum %d x %d y %d level %d",
1708. GetName(), dwVnum, posTarget.x, posTarget.y, bSkillLevel);
1709. }
1711. // ³ª¿¡°Ô ¾²´Â ½ºÅ³Àº ³» À§Ä¡¸¦ ¾´´Ù.
1712. //if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
1713. // posTarget = GetXYZ();
1715. // ½ºÇ÷¡½¬°¡ ¾Æ´Ñ ½ºÅ³Àº ÁÖÀ§À̸é ÀÌ»óÇÏ´Ù
1716. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
1717. return BATTLE_NONE;
1719. if (0 == bSkillLevel)
1720. {
1721. if ((bSkillLevel = GetSkillLevel(pkSk->dwVnum)) == 0)
1722. {
1723. return BATTLE_NONE;
1724. }
1725. }
1727. const float k = 1.0 * GetSkillPower(pkSk->dwVnum, bSkillLevel) * pkSk->bMaxLevel / 100;
1729. pkSk->SetPointVar("k", k);
1730. pkSk->kSplashAroundDamageAdjustPoly.SetVar("k", k);
1732. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MELEE_DAMAGE))
1733. {
1734. pkSk->SetPointVar("atk", CalcMeleeDamage(this, this, true, false));
1735. }
1736. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MAGIC_DAMAGE))
1737. {
1738. pkSk->SetPointVar("atk", CalcMagicDamage(this, this));
1739. }
1740. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_ARROW_DAMAGE))
1741. {
1742. LPITEM pkBow, pkArrow;
1743. if (1 == GetArrowAndBow(&pkBow, &pkArrow, 1))
1744. {
1745. pkSk->SetPointVar("atk", CalcArrowDamage(this, this, pkBow, pkArrow, true));
1746. }
1747. else
1748. {
1749. pkSk->SetPointVar("atk", 0);
1750. }
1751. }
1753. if (pkSk->bPointOn == POINT_MOV_SPEED)
1754. {
1755. pkSk->SetPointVar("maxv", this->GetLimitPoint(POINT_MOV_SPEED));
1756. }
1758. pkSk->SetPointVar("lv", GetLevel());
1759. pkSk->SetPointVar("iq", GetPoint(POINT_IQ));
1760. pkSk->SetPointVar("str", GetPoint(POINT_ST));
1761. pkSk->SetPointVar("dex", GetPoint(POINT_DX));
1762. pkSk->SetPointVar("con", GetPoint(POINT_HT));
1763. pkSk->SetPointVar("maxhp", this->GetMaxHP());
1764. pkSk->SetPointVar("maxsp", this->GetMaxSP());
1765. pkSk->SetPointVar("chain", 0);
1766. pkSk->SetPointVar("ar", CalcAttackRating(this, this));
1767. pkSk->SetPointVar("def", GetPoint(POINT_DEF_GRADE));
1768. pkSk->SetPointVar("odef", GetPoint(POINT_DEF_GRADE) - GetPoint(POINT_DEF_GRADE_BONUS));
1769. pkSk->SetPointVar("horse_level", GetHorseLevel());
1771. if (pkSk->bSkillAttrType != SKILL_ATTR_TYPE_NORMAL)
1772. OnMove(true);
1774. LPITEM pkWeapon = GetWear(WEAR_WEAPON);
1776. SetPolyVarForAttack(this, pkSk, pkWeapon);
1778. pkSk->SetDurationVar("k", k/*bSkillLevel*/);
1780. int iAmount = (int) pkSk->kPointPoly.Eval();
1781. int iAmount2 = (int) pkSk->kPointPoly2.Eval();
1783. // ADD_GRANDMASTER_SKILL
1784. int iAmount3 = (int) pkSk->kPointPoly3.Eval();
1786. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
1787. {
1788. /*
1789. if (iAmount >= 0)
1790. iAmount += (int) m_pkSk->kMasterBonusPoly.Eval();
1791. else
1792. iAmount -= (int) m_pkSk->kMasterBonusPoly.Eval();
1793. */
1794. iAmount = (int) pkSk->kMasterBonusPoly.Eval();
1795. }
1797. if (test_server && iAmount == 0 && pkSk->bPointOn != POINT_NONE)
1798. {
1799. ChatPacket(CHAT_TYPE_INFO, "È¿°ú°¡ ¾ø½À´Ï´Ù. ½ºÅ³ °ø½ÄÀ» È®ÀÎÇϼ¼¿ä");
1800. }
1802. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_REMOVE_BAD_AFFECT))
1803. {
1804. if (number(1, 100) <= iAmount2)
1805. {
1806. RemoveBadAffect();
1807. }
1808. }
1809. // END_OF_ADD_GRANDMASTER_SKILL
1811. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_ATTACK | SKILL_FLAG_USE_MELEE_DAMAGE | SKILL_FLAG_USE_MAGIC_DAMAGE))
1812. {
1813. //
1814. // °ø°Ý ½ºÅ³ÀÏ °æ¿ì
1815. //
1816. bool bAdded = false;
1818. if (pkSk->bPointOn == POINT_HP && iAmount < 0)
1819. {
1820. int iAG = 0;
1822. FuncSplashDamage f(posTarget.x, posTarget.y, pkSk, this, iAmount, iAG, pkSk->lMaxHit, pkWeapon, m_bDisableCooltime, IsPC()?&m_SkillUseInfo[dwVnum]:NULL, GetSkillPower(dwVnum, bSkillLevel));
1824. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
1825. {
1826. if (GetSectree())
1827. GetSectree()->ForEachAround(f);
1828. }
1829. else
1830. {
1831. //if (dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN skill call FuncSplashDamage %s", GetName());
1832. f(this);
1833. }
1834. }
1835. else
1836. {
1837. //if (dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN skill no damage %d %s", iAmount, GetName());
1838. int iDur = (int) pkSk->kDurationPoly.Eval();
1840. if (IsPC())
1841. if (!(dwVnum >= GUILD_SKILL_START && dwVnum <= GUILD_SKILL_END)) // ±æµå ½ºÅ³Àº ÄðŸÀÓ Ã³¸®¸¦ ÇÏÁö ¾Ê´Â´Ù.
1842. if (!m_bDisableCooltime && !m_SkillUseInfo[dwVnum].HitOnce(dwVnum) && dwVnum != SKILL_MUYEONG)
1843. {
1844. //if (dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN skill cannot hit %s", GetName());
1845. return BATTLE_NONE;
1846. }
1849. if (iDur > 0)
1850. {
1851. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
1853. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
1854. AddAffect(pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true);
1855. else
1856. {
1857. if (GetSectree())
1858. {
1859. FuncSplashAffect f(this, posTarget.x, posTarget.y, pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true, pkSk->lMaxHit);
1860. GetSectree()->ForEachAround(f);
1861. }
1862. }
1863. bAdded = true;
1864. }
1865. }
1867. if (pkSk->bPointOn2 != POINT_NONE)
1868. {
1869. int iDur = (int) pkSk->kDurationPoly2.Eval();
1871. sys_log(1, "try second %u %d %d", pkSk->dwVnum, pkSk->bPointOn2, iDur);
1873. if (iDur > 0)
1874. {
1875. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
1877. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
1878. AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded);
1879. else
1880. {
1881. if (GetSectree())
1882. {
1883. FuncSplashAffect f(this, posTarget.x, posTarget.y, pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded, pkSk->lMaxHit);
1884. GetSectree()->ForEachAround(f);
1885. }
1886. }
1887. bAdded = true;
1888. }
1889. else
1890. {
1891. PointChange(pkSk->bPointOn2, iAmount2);
1892. }
1893. }
1895. // ADD_GRANDMASTER_SKILL
1896. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER && pkSk->bPointOn3 != POINT_NONE)
1897. {
1898. int iDur = (int) pkSk->kDurationPoly3.Eval();
1900. if (iDur > 0)
1901. {
1902. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
1904. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
1905. AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, 0 /*pkSk->dwAffectFlag3*/, iDur, 0, !bAdded);
1906. else
1907. {
1908. if (GetSectree())
1909. {
1910. FuncSplashAffect f(this, posTarget.x, posTarget.y, pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn3, iAmount3, 0 /*pkSk->dwAffectFlag3*/, iDur, 0, !bAdded, pkSk->lMaxHit);
1911. GetSectree()->ForEachAround(f);
1912. }
1913. }
1914. }
1915. else
1916. {
1917. PointChange(pkSk->bPointOn3, iAmount3);
1918. }
1919. }
1920. // END_OF_ADD_GRANDMASTER_SKILL
1922. return BATTLE_DAMAGE;
1923. }
1924. else
1925. {
1926. bool bAdded = false;
1927. int iDur = (int) pkSk->kDurationPoly.Eval();
1929. if (iDur > 0)
1930. {
1931. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
1932. // AffectFlag°¡ ¾ø°Å³ª, toggle ÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó¸é..
1933. pkSk->kDurationSPCostPoly.SetVar("k", k/*bSkillLevel*/);
1935. AddAffect(pkSk->dwVnum,
1936. pkSk->bPointOn,
1937. iAmount,
1938. pkSk->dwAffectFlag,
1939. iDur,
1940. (long) pkSk->kDurationSPCostPoly.Eval(),
1941. !bAdded);
1943. bAdded = true;
1944. }
1945. else
1946. {
1947. PointChange(pkSk->bPointOn, iAmount);
1948. }
1950. if (pkSk->bPointOn2 != POINT_NONE)
1951. {
1952. int iDur = (int) pkSk->kDurationPoly2.Eval();
1954. if (iDur > 0)
1955. {
1956. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
1957. AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded);
1958. bAdded = true;
1959. }
1960. else
1961. {
1962. PointChange(pkSk->bPointOn2, iAmount2);
1963. }
1964. }
1966. // ADD_GRANDMASTER_SKILL
1967. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER && pkSk->bPointOn3 != POINT_NONE)
1968. {
1969. int iDur = (int) pkSk->kDurationPoly3.Eval();
1971. if (iDur > 0)
1972. {
1973. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
1974. AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, 0 /*pkSk->dwAffectFlag3*/, iDur, 0, !bAdded);
1975. }
1976. else
1977. {
1978. PointChange(pkSk->bPointOn3, iAmount3);
1979. }
1980. }
1981. // END_OF_ADD_GRANDMASTER_SKILL
1983. return BATTLE_NONE;
1984. }
1985. }
1987. // bSkillLevel ÀÎÀÚ°¡ 0ÀÌ ¾Æ´Ò °æ¿ì¿¡´Â m_abSkillLevels¸¦ »ç¿ëÇÏÁö ¾Ê°í °­Á¦·Î
1988. // bSkillLevel·Î °è»êÇÑ´Ù.
1989. int CHARACTER::ComputeSkill(DWORD dwVnum, LPCHARACTER pkVictim, BYTE bSkillLevel)
1990. {
1991. const bool bCanUseHorseSkill = CanUseHorseSkill();
1993. // ¸»À» Ÿ°íÀÖÁö¸¸ ½ºÅ³Àº »ç¿ëÇÒ ¼ö ¾ø´Â »óŶó¸é return
1994. if (false == bCanUseHorseSkill && true == IsRiding())
1995. return BATTLE_NONE;
1997. if (IsPolymorphed())
1998. return BATTLE_NONE;
2000. if (g_bSkillDisable)
2001. return BATTLE_NONE;
2003. CSkillProto* pkSk = CSkillManager::instance().Get(dwVnum);
2005. if (!pkSk)
2006. return BATTLE_NONE;
2008. if (bCanUseHorseSkill && pkSk->dwType != SKILL_TYPE_HORSE)
2009. return BATTLE_NONE;
2011. if (!bCanUseHorseSkill && pkSk->dwType == SKILL_TYPE_HORSE)
2012. return BATTLE_NONE;
2015. // »ó´ë¹æ¿¡°Ô ¾²´Â °ÍÀÌ ¾Æ´Ï¸é ³ª¿¡°Ô ½á¾ß ÇÑ´Ù.
2016. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
2017. pkVictim = this;
2019. if (!pkVictim)
2020. {
2021. if (test_server)
2022. sys_log(0, "ComputeSkill: %s Victim == null, skill %d", GetName(), dwVnum);
2024. return BATTLE_NONE;
2025. }
2027. if (pkSk->dwTargetRange && DISTANCE_SQRT(GetX() - pkVictim->GetX(), GetY() - pkVictim->GetY()) >= pkSk->dwTargetRange + 50)
2028. {
2029. if (test_server)
2030. sys_log(0, "ComputeSkill: Victim too far, skill %d : %s to %s (distance %u limit %u)",
2031. dwVnum,
2032. GetName(),
2033. pkVictim->GetName(),
2034. (long)DISTANCE_SQRT(GetX() - pkVictim->GetX(), GetY() - pkVictim->GetY()),
2035. pkSk->dwTargetRange);
2037. return BATTLE_NONE;
2038. }
2040. if (0 == bSkillLevel)
2041. {
2042. if ((bSkillLevel = GetSkillLevel(pkSk->dwVnum)) == 0)
2043. {
2044. if (test_server)
2045. sys_log(0, "ComputeSkill : name:%s vnum:%d skillLevelBySkill : %d ", GetName(), pkSk->dwVnum, bSkillLevel);
2046. return BATTLE_NONE;
2047. }
2048. }
2050. if (pkVictim->IsAffectFlag(AFF_PABEOP) && pkVictim->IsGoodAffect(dwVnum))
2051. {
2052. return BATTLE_NONE;
2053. }
2055. const float k = 1.0 * GetSkillPower(pkSk->dwVnum, bSkillLevel) * pkSk->bMaxLevel / 100;
2057. pkSk->SetPointVar("k", k);
2058. pkSk->kSplashAroundDamageAdjustPoly.SetVar("k", k);
2060. if (pkSk->dwType == SKILL_TYPE_HORSE)
2061. {
2062. LPITEM pkBow, pkArrow;
2063. if (1 == GetArrowAndBow(&pkBow, &pkArrow, 1))
2064. {
2065. pkSk->SetPointVar("atk", CalcArrowDamage(this, pkVictim, pkBow, pkArrow, true));
2066. }
2067. else
2068. {
2069. pkSk->SetPointVar("atk", CalcMeleeDamage(this, pkVictim, true, false));
2070. }
2071. }
2072. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MELEE_DAMAGE))
2073. {
2074. pkSk->SetPointVar("atk", CalcMeleeDamage(this, pkVictim, true, false));
2075. }
2076. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MAGIC_DAMAGE))
2077. {
2078. pkSk->SetPointVar("atk", CalcMagicDamage(this, pkVictim));
2079. }
2080. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_ARROW_DAMAGE))
2081. {
2082. LPITEM pkBow, pkArrow;
2083. if (1 == GetArrowAndBow(&pkBow, &pkArrow, 1))
2084. {
2085. pkSk->SetPointVar("atk", CalcArrowDamage(this, pkVictim, pkBow, pkArrow, true));
2086. }
2087. else
2088. {
2089. pkSk->SetPointVar("atk", 0);
2090. }
2091. }
2093. if (pkSk->bPointOn == POINT_MOV_SPEED)
2094. {
2095. pkSk->SetPointVar("maxv", pkVictim->GetLimitPoint(POINT_MOV_SPEED));
2096. }
2098. pkSk->SetPointVar("lv", GetLevel());
2099. pkSk->SetPointVar("iq", GetPoint(POINT_IQ));
2100. pkSk->SetPointVar("str", GetPoint(POINT_ST));
2101. pkSk->SetPointVar("dex", GetPoint(POINT_DX));
2102. pkSk->SetPointVar("con", GetPoint(POINT_HT));
2103. pkSk->SetPointVar("maxhp", pkVictim->GetMaxHP());
2104. pkSk->SetPointVar("maxsp", pkVictim->GetMaxSP());
2105. pkSk->SetPointVar("chain", 0);
2106. pkSk->SetPointVar("ar", CalcAttackRating(this, pkVictim));
2107. pkSk->SetPointVar("def", GetPoint(POINT_DEF_GRADE));
2108. pkSk->SetPointVar("odef", GetPoint(POINT_DEF_GRADE) - GetPoint(POINT_DEF_GRADE_BONUS));
2109. pkSk->SetPointVar("horse_level", GetHorseLevel());
2111. if (pkSk->bSkillAttrType != SKILL_ATTR_TYPE_NORMAL)
2112. OnMove(true);
2114. LPITEM pkWeapon = GetWear(WEAR_WEAPON);
2116. SetPolyVarForAttack(this, pkSk, pkWeapon);
2118. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
2119. pkSk->kDurationPoly2.SetVar("k", k/*bSkillLevel*/);
2121. int iAmount = (int) pkSk->kPointPoly.Eval();
2122. int iAmount2 = (int) pkSk->kPointPoly2.Eval();
2123. int iAmount3 = (int) pkSk->kPointPoly3.Eval();
2125. if (test_server && IsPC())
2126. sys_log(0, "iAmount: %d %d %d , atk:%f skLevel:%f k:%f GetSkillPower(%d) MaxLevel:%d Per:%f",
2127. iAmount, iAmount2, iAmount3,
2128. pkSk->kPointPoly.GetVar("atk"),
2129. pkSk->kPointPoly.GetVar("k"),
2130. k,
2131. GetSkillPower(pkSk->dwVnum, bSkillLevel),
2132. pkSk->bMaxLevel,
2133. pkSk->bMaxLevel/100
2134. );
2136. // ADD_GRANDMASTER_SKILL
2137. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
2138. {
2139. iAmount = (int) pkSk->kMasterBonusPoly.Eval();
2140. }
2142. if (test_server && iAmount == 0 && pkSk->bPointOn != POINT_NONE)
2143. {
2144. ChatPacket(CHAT_TYPE_INFO, "È¿°ú°¡ ¾ø½À´Ï´Ù. ½ºÅ³ °ø½ÄÀ» È®ÀÎÇϼ¼¿ä");
2145. }
2146. // END_OF_ADD_GRANDMASTER_SKILL
2148. //sys_log(0, "XXX SKILL Calc %d Amount %d", dwVnum, iAmount);
2150. // REMOVE_BAD_AFFECT_BUG_FIX
2151. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_REMOVE_BAD_AFFECT))
2152. {
2153. if (number(1, 100) <= iAmount2)
2154. {
2155. pkVictim->RemoveBadAffect();
2156. }
2157. }
2158. // END_OF_REMOVE_BAD_AFFECT_BUG_FIX
2160. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_ATTACK | SKILL_FLAG_USE_MELEE_DAMAGE | SKILL_FLAG_USE_MAGIC_DAMAGE) &&
2161. !(pkSk->dwVnum == SKILL_MUYEONG && pkVictim == this) && !(pkSk->IsChargeSkill() && pkVictim == this))
2162. {
2163. bool bAdded = false;
2165. if (pkSk->bPointOn == POINT_HP && iAmount < 0)
2166. {
2167. int iAG = 0;
2170. FuncSplashDamage f(pkVictim->GetX(), pkVictim->GetY(), pkSk, this, iAmount, iAG, pkSk->lMaxHit, pkWeapon, m_bDisableCooltime, IsPC()?&m_SkillUseInfo[dwVnum]:NULL, GetSkillPower(dwVnum, bSkillLevel));
2171. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
2172. {
2173. if (pkVictim->GetSectree())
2174. pkVictim->GetSectree()->ForEachAround(f);
2175. }
2176. else
2177. {
2178. f(pkVictim);
2179. }
2180. }
2181. else
2182. {
2183. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
2184. int iDur = (int) pkSk->kDurationPoly.Eval();
2187. if (IsPC())
2188. if (!(dwVnum >= GUILD_SKILL_START && dwVnum <= GUILD_SKILL_END)) // ±æµå ½ºÅ³Àº ÄðŸÀÓ Ã³¸®¸¦ ÇÏÁö ¾Ê´Â´Ù.
2189. if (!m_bDisableCooltime && !m_SkillUseInfo[dwVnum].HitOnce(dwVnum) && dwVnum != SKILL_MUYEONG)
2190. {
2191. return BATTLE_NONE;
2192. }
2194. if (iDur > 0)
2195. {
2196. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
2198. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
2199. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true);
2200. else
2201. {
2202. if (pkVictim->GetSectree())
2203. {
2204. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true, pkSk->lMaxHit);
2205. pkVictim->GetSectree()->ForEachAround(f);
2206. }
2207. }
2208. bAdded = true;
2209. }
2210. }
2212. if (pkSk->bPointOn2 != POINT_NONE && !pkSk->IsChargeSkill())
2213. {
2214. pkSk->kDurationPoly2.SetVar("k", k/*bSkillLevel*/);
2215. int iDur = (int) pkSk->kDurationPoly2.Eval();
2217. if (iDur > 0)
2218. {
2219. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
2221. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
2222. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded);
2223. else
2224. {
2225. if (pkVictim->GetSectree())
2226. {
2227. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded, pkSk->lMaxHit);
2228. pkVictim->GetSectree()->ForEachAround(f);
2229. }
2230. }
2232. bAdded = true;
2233. }
2234. else
2235. {
2236. pkVictim->PointChange(pkSk->bPointOn2, iAmount2);
2237. }
2238. }
2240. // ADD_GRANDMASTER_SKILL
2241. if (pkSk->bPointOn3 != POINT_NONE && !pkSk->IsChargeSkill() && GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
2242. {
2243. pkSk->kDurationPoly3.SetVar("k", k/*bSkillLevel*/);
2244. int iDur = (int) pkSk->kDurationPoly3.Eval();
2247. if (iDur > 0)
2248. {
2249. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
2251. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
2252. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded);
2253. else
2254. {
2255. if (pkVictim->GetSectree())
2256. {
2257. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded, pkSk->lMaxHit);
2258. pkVictim->GetSectree()->ForEachAround(f);
2259. }
2260. }
2262. bAdded = true;
2263. }
2264. else
2265. {
2266. pkVictim->PointChange(pkSk->bPointOn3, iAmount3);
2267. }
2268. }
2269. // END_OF_ADD_GRANDMASTER_SKILL
2271. return BATTLE_DAMAGE;
2272. }
2273. else
2274. {
2275. if (dwVnum == SKILL_MUYEONG)
2276. {
2277. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
2278. pkSk->kDurationSPCostPoly.SetVar("k", k/*bSkillLevel*/);
2280. int iDur = (long) pkSk->kDurationPoly.Eval();
2281. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
2283. if (pkVictim == this)
2284. AddAffect(dwVnum,
2285. POINT_NONE, 0,
2286. AFF_MUYEONG,
2287. iDur,
2288. (long) pkSk->kDurationSPCostPoly.Eval(),
2289. true);
2291. return BATTLE_NONE;
2292. }
2294. bool bAdded = false;
2295. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
2296. int iDur = (int) pkSk->kDurationPoly.Eval();
2298. if (iDur > 0)
2299. {
2300. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
2301. // AffectFlag°¡ ¾ø°Å³ª, toggle ÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó¸é..
2302. pkSk->kDurationSPCostPoly.SetVar("k", k/*bSkillLevel*/);
2304. if (pkSk->bPointOn2 != POINT_NONE)
2305. {
2306. pkVictim->RemoveAffect(pkSk->dwVnum);
2308. int iDur2 = (int) pkSk->kDurationPoly2.Eval();
2310. if (iDur2 > 0)
2311. {
2312. if (test_server)
2313. sys_log(0, "SKILL_AFFECT: %s %s Dur:%d To:%d Amount:%d",
2314. GetName(),
2315. pkSk->szName,
2316. iDur2,
2317. pkSk->bPointOn2,
2318. iAmount2);
2320. iDur2 += GetPoint(POINT_PARTY_BUFFER_BONUS);
2321. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur2, 0, false);
2322. }
2323. else
2324. {
2325. pkVictim->PointChange(pkSk->bPointOn2, iAmount2);
2326. }
2328. DWORD affact_flag = pkSk->dwAffectFlag;
2330. // ADD_GRANDMASTER_SKILL
2331. //if (g_iUseLocale)
2332. if ( !LC_IsYMIR() )
2333. {
2334. if ((pkSk->dwVnum == SKILL_CHUNKEON && GetUsedSkillMasterType(pkSk->dwVnum) < SKILL_GRAND_MASTER))
2335. affact_flag = AFF_CHEONGEUN_WITH_FALL;
2336. }
2337. else
2338. {
2339. if ((pkSk->dwVnum == SKILL_CHUNKEON && GetUsedSkillMasterType(pkSk->dwVnum) < SKILL_MASTER))
2340. affact_flag = AFF_CHEONGEUN_WITH_FALL;
2341. }
2342. // END_OF_ADD_GRANDMASTER_SKILL
2344. pkVictim->AddAffect(pkSk->dwVnum,
2345. pkSk->bPointOn,
2346. iAmount,
2347. affact_flag,
2348. iDur,
2349. (long) pkSk->kDurationSPCostPoly.Eval(),
2350. false);
2351. }
2352. else
2353. {
2354. if (test_server)
2355. sys_log(0, "SKILL_AFFECT: %s %s Dur:%d To:%d Amount:%d",
2356. GetName(),
2357. pkSk->szName,
2358. iDur,
2359. pkSk->bPointOn,
2360. iAmount);
2362. pkVictim->AddAffect(pkSk->dwVnum,
2363. pkSk->bPointOn,
2364. iAmount,
2365. pkSk->dwAffectFlag,
2366. iDur,
2367. (long) pkSk->kDurationSPCostPoly.Eval(),
2368. // ADD_GRANDMASTER_SKILL
2369. !bAdded);
2370. // END_OF_ADD_GRANDMASTER_SKILL
2371. }
2373. bAdded = true;
2374. }
2375. else
2376. {
2377. if (!pkSk->IsChargeSkill())
2378. pkVictim->PointChange(pkSk->bPointOn, iAmount);
2380. if (pkSk->bPointOn2 != POINT_NONE)
2381. {
2382. pkVictim->RemoveAffect(pkSk->dwVnum);
2384. int iDur2 = (int) pkSk->kDurationPoly2.Eval();
2386. if (iDur2 > 0)
2387. {
2388. iDur2 += GetPoint(POINT_PARTY_BUFFER_BONUS);
2390. if (pkSk->IsChargeSkill())
2391. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, AFF_TANHWAN_DASH, iDur2, 0, false);
2392. else
2393. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur2, 0, false);
2394. }
2395. else
2396. {
2397. pkVictim->PointChange(pkSk->bPointOn2, iAmount2);
2398. }
2400. }
2401. }
2403. // ADD_GRANDMASTER_SKILL
2404. if (pkSk->bPointOn3 != POINT_NONE && !pkSk->IsChargeSkill() && GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
2405. {
2407. pkSk->kDurationPoly3.SetVar("k", k/*bSkillLevel*/);
2408. int iDur = (int) pkSk->kDurationPoly3.Eval();
2410. sys_log(0, "try third %u %d %d %d 1894", pkSk->dwVnum, pkSk->bPointOn3, iDur, iAmount3);
2412. if (iDur > 0)
2413. {
2414. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
2416. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
2417. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded);
2418. else
2419. {
2420. if (pkVictim->GetSectree())
2421. {
2422. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded, pkSk->lMaxHit);
2423. pkVictim->GetSectree()->ForEachAround(f);
2424. }
2425. }
2427. bAdded = true;
2428. }
2429. else
2430. {
2431. pkVictim->PointChange(pkSk->bPointOn3, iAmount3);
2432. }
2433. }
2434. // END_OF_ADD_GRANDMASTER_SKILL
2436. return BATTLE_NONE;
2437. }
2438. }
2440. bool CHARACTER::UseSkill(DWORD dwVnum, LPCHARACTER pkVictim, bool bUseGrandMaster)
2441. {
2442. if (false == CanUseSkill(dwVnum))
2443. return false;
2445. // NO_GRANDMASTER
2446. if (test_server)
2447. {
2448. if (quest::CQuestManager::instance().GetEventFlag("no_grand_master"))
2449. {
2450. bUseGrandMaster = false;
2451. }
2452. }
2453. // END_OF_NO_GRANDMASTER
2455. if (g_bSkillDisable)
2456. return false;
2458. if (IsObserverMode())
2459. return false;
2461. if (!CanMove())
2462. return false;
2464. if (IsPolymorphed())
2465. return false;
2467. const bool bCanUseHorseSkill = CanUseHorseSkill();
2470. if (dwVnum == SKILL_HORSE_SUMMON)
2471. {
2472. if (GetSkillLevel(dwVnum) == 0)
2473. return false;
2475. if (GetHorseLevel() <= 0)
2476. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»ÀÌ ¾ø½À´Ï´Ù. ¸¶±Â°£ °æºñº´À» ã¾Æ°¡¼¼¿ä."));
2477. else
2478. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸» ¼Òȯ ¾ÆÀÌÅÛÀ» »ç¿ëÇϼ¼¿ä."));
2480. return true;
2481. }
2483. // ¸»À» Ÿ°íÀÖÁö¸¸ ½ºÅ³Àº »ç¿ëÇÒ ¼ö ¾ø´Â »óŶó¸é return false
2484. if (false == bCanUseHorseSkill && true == IsRiding())
2485. return false;
2487. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
2488. sys_log(0, "%s: USE_SKILL: %d pkVictim %p", GetName(), dwVnum, get_pointer(pkVictim));
2490. if (!pkSk)
2491. return false;
2493. if (bCanUseHorseSkill && pkSk->dwType != SKILL_TYPE_HORSE)
2494. return BATTLE_NONE;
2496. if (!bCanUseHorseSkill && pkSk->dwType == SKILL_TYPE_HORSE)
2497. return BATTLE_NONE;
2499. if (GetSkillLevel(dwVnum) == 0)
2500. return false;
2503. // NO_GRANDMASTER
2504. if (GetSkillMasterType(dwVnum) < SKILL_GRAND_MASTER)
2505. bUseGrandMaster = false;
2506. // END_OF_NO_GRANDMASTER
2508. // MINING
2509. if (GetWear(WEAR_WEAPON) && (GetWear(WEAR_WEAPON)->GetType() == ITEM_ROD || GetWear(WEAR_WEAPON)->GetType() == ITEM_PICK))
2510. return false;
2511. // END_OF_MINING
2513. m_SkillUseInfo[dwVnum].TargetVIDMap.clear();
2515. if (pkSk->IsChargeSkill())
2516. {
2517. if ((IsAffectFlag(AFF_TANHWAN_DASH)) || (pkVictim && pkVictim != this))
2518. {
2519. if (!pkVictim)
2520. return false;
2522. if (!IsAffectFlag(AFF_TANHWAN_DASH))
2523. {
2524. if (!UseSkill(dwVnum, this))
2525. return false;
2526. }
2528. m_SkillUseInfo[dwVnum].SetMainTargetVID(pkVictim->GetVID());
2529. // DASH »óÅÂÀÇ ÅºÈ¯°ÝÀº °ø°Ý±â¼ú
2530. ComputeSkill(dwVnum, pkVictim);
2531. RemoveAffect(dwVnum);
2532. return true;
2533. }
2534. }
2536. if (dwVnum == SKILL_COMBO)
2537. {
2538. if (m_bComboIndex)
2539. m_bComboIndex = 0;
2540. else
2541. m_bComboIndex = GetSkillLevel(SKILL_COMBO);
2543. ChatPacket(CHAT_TYPE_COMMAND, "combo %d", m_bComboIndex);
2544. return true;
2545. }
2547. // Toggle ÇÒ ¶§´Â SP¸¦ ¾²Áö ¾ÊÀ½ (SelfOnly·Î ±¸ºÐ)
2548. if ((0 != pkSk->dwAffectFlag || pkSk->dwVnum == SKILL_MUYEONG) && (pkSk->dwFlag & SKILL_FLAG_TOGGLE) && RemoveAffect(pkSk->dwVnum))
2549. {
2550. return true;
2551. }
2553. if (IsAffectFlag(AFFECT_REVIVE_INVISIBLE))
2554. RemoveAffect(AFFECT_REVIVE_INVISIBLE);
2556. const float k = 1.0 * GetSkillPower(pkSk->dwVnum) * pkSk->bMaxLevel / 100;
2558. pkSk->SetPointVar("k", k);
2559. pkSk->kSplashAroundDamageAdjustPoly.SetVar("k", k);
2561. // ÄðŸÀÓ Ã¼Å©
2562. pkSk->kCooldownPoly.SetVar("k", k);
2563. int iCooltime = (int) pkSk->kCooldownPoly.Eval();
2564. int lMaxHit = pkSk->lMaxHit ? pkSk->lMaxHit : -1;
2566. pkSk->SetSPCostVar("k", k);
2568. DWORD dwCur = get_dword_time();
2570. if (dwVnum == SKILL_TERROR && m_SkillUseInfo[dwVnum].bUsed && m_SkillUseInfo[dwVnum].dwNextSkillUsableTime > dwCur )
2571. {
2572. sys_log(0, " SKILL_TERROR's Cooltime is not delta over %u", m_SkillUseInfo[dwVnum].dwNextSkillUsableTime - dwCur );
2573. return false;
2574. }
2576. int iNeededSP = 0;
2578. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_HP_AS_COST))
2579. {
2580. pkSk->SetSPCostVar("maxhp", GetMaxHP());
2581. pkSk->SetSPCostVar("v", GetHP());
2582. iNeededSP = (int) pkSk->kSPCostPoly.Eval();
2584. // ADD_GRANDMASTER_SKILL
2585. if (GetSkillMasterType(dwVnum) >= SKILL_GRAND_MASTER && bUseGrandMaster)
2586. {
2587. iNeededSP = (int) pkSk->kGrandMasterAddSPCostPoly.Eval();
2588. }
2589. // END_OF_ADD_GRANDMASTER_SKILL
2591. if (GetHP() < iNeededSP)
2592. return false;
2594. PointChange(POINT_HP, -iNeededSP);
2595. }
2596. else
2597. {
2598. // SKILL_FOMULA_REFACTORING
2599. pkSk->SetSPCostVar("maxhp", GetMaxHP());
2600. pkSk->SetSPCostVar("maxv", GetMaxSP());
2601. pkSk->SetSPCostVar("v", GetSP());
2603. iNeededSP = (int) pkSk->kSPCostPoly.Eval();
2605. if (GetSkillMasterType(dwVnum) >= SKILL_GRAND_MASTER && bUseGrandMaster)
2606. {
2607. iNeededSP = (int) pkSk->kGrandMasterAddSPCostPoly.Eval();
2608. }
2609. // END_OF_SKILL_FOMULA_REFACTORING
2611. if (GetSP() < iNeededSP)
2612. return false;
2614. if (test_server)
2615. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s SP¼Ò¸ð: %d"), pkSk->szName, iNeededSP);
2617. PointChange(POINT_SP, -iNeededSP);
2618. }
2620. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
2621. pkVictim = this;
2623. if ((pkSk->dwVnum == SKILL_MUYEONG) || (pkSk->IsChargeSkill() && !IsAffectFlag(AFF_TANHWAN_DASH) && !pkVictim))
2624. {
2625. // óÀ½ »ç¿ëÇÏ´Â ¹«¿µÁøÀº Àڽſ¡°Ô Affect¸¦ ºÙÀδÙ.
2626. pkVictim = this;
2627. }
2629. int iSplashCount = 1;
2631. if (false == m_bDisableCooltime)
2632. {
2633. if (false ==
2634. m_SkillUseInfo[dwVnum].UseSkill(
2635. bUseGrandMaster,
2636. (NULL != pkVictim && SKILL_HORSE_WILDATTACK != dwVnum) ? pkVictim->GetVID() : NULL,
2637. ComputeCooltime(iCooltime * 1000),
2638. iSplashCount,
2639. lMaxHit))
2640. {
2641. if (test_server)
2642. ChatPacket(CHAT_TYPE_NOTICE, "cooltime not finished %s %d", pkSk->szName, iCooltime);
2644. return false;
2645. }
2646. }
2648. if (dwVnum == SKILL_CHAIN)
2649. {
2650. ResetChainLightningIndex();
2651. AddChainLightningExcept(pkVictim);
2652. }
2655. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
2656. ComputeSkill(dwVnum, this);
2657. else if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_ATTACK))
2658. ComputeSkill(dwVnum, pkVictim);
2659. else if (dwVnum == SKILL_BYEURAK)
2660. ComputeSkill(dwVnum, pkVictim);
2661. else if (dwVnum == SKILL_MUYEONG || pkSk->IsChargeSkill())
2662. ComputeSkill(dwVnum, pkVictim);
2664. m_dwLastSkillTime = get_dword_time();
2666. return true;
2667. }
2669. int CHARACTER::GetUsedSkillMasterType(DWORD dwVnum)
2670. {
2671. const TSkillUseInfo& rInfo = m_SkillUseInfo[dwVnum];
2673. if (GetSkillMasterType(dwVnum) < SKILL_GRAND_MASTER)
2674. return GetSkillMasterType(dwVnum);
2676. if (rInfo.isGrandMaster)
2677. return GetSkillMasterType(dwVnum);
2679. return MIN(GetSkillMasterType(dwVnum), SKILL_MASTER);
2680. }
2682. int CHARACTER::GetSkillMasterType(DWORD dwVnum) const
2683. {
2684. if (!IsPC())
2685. return 0;
2687. if (dwVnum >= SKILL_MAX_NUM)
2688. {
2689. sys_err("%s skill vnum overflow %u", GetName(), dwVnum);
2690. return 0;
2691. }
2693. return m_pSkillLevels ? m_pSkillLevels[dwVnum].bMasterType:SKILL_NORMAL;
2694. }
2696. int CHARACTER::GetSkillPower(DWORD dwVnum, BYTE bLevel) const
2697. {
2698. // Àξî¹ÝÁö ¾ÆÀÌÅÛ
2699. if (dwVnum >= SKILL_LANGUAGE1 && dwVnum <= SKILL_LANGUAGE3 && IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
2700. {
2701. return 100;
2702. }
2704. if (dwVnum >= GUILD_SKILL_START && dwVnum <= GUILD_SKILL_END)
2705. {
2706. if (GetGuild())
2707. return 100 * GetGuild()->GetSkillLevel(dwVnum) / 7 / 7;
2708. else
2709. return 0;
2710. }
2712. if (bLevel)
2713. {
2714. //SKILL_POWER_BY_LEVEL
2715. return GetSkillPowerByLevel(bLevel, true);
2716. //END_SKILL_POWER_BY_LEVEL;
2717. }
2719. if (dwVnum >= SKILL_MAX_NUM)
2720. {
2721. sys_err("%s skill vnum overflow %u", GetName(), dwVnum);
2722. return 0;
2723. }
2725. //SKILL_POWER_BY_LEVEL
2726. return GetSkillPowerByLevel(GetSkillLevel(dwVnum));
2727. //SKILL_POWER_BY_LEVEL
2728. }
2730. int CHARACTER::GetSkillLevel(DWORD dwVnum) const
2731. {
2732. if (dwVnum >= SKILL_MAX_NUM)
2733. {
2734. sys_err("%s skill vnum overflow %u", GetName(), dwVnum);
2735. sys_log(0, "%s skill vnum overflow %u", GetName(), dwVnum);
2736. return 0;
2737. }
2739. return MIN(SKILL_MAX_LEVEL, m_pSkillLevels ? m_pSkillLevels[dwVnum].bLevel : 0);
2740. }
2742. EVENTFUNC(skill_muyoung_event)
2743. {
2744. char_event_info* info = dynamic_cast<char_event_info*>( event->info );
2746. if ( info == NULL )
2747. {
2748. sys_err( "skill_muyoung_event> <Factor> Null pointer" );
2749. return 0;
2750. }
2752. LPCHARACTER ch = info->ch;
2754. if (ch == NULL) { // <Factor>
2755. return 0;
2756. }
2758. if (!ch->IsAffectFlag(AFF_MUYEONG))
2759. {
2760. ch->StopMuyeongEvent();
2761. return 0;
2762. }
2764. // 1. Find Victim
2765. FFindNearVictim f(ch, ch);
2766. if (ch->GetSectree())
2767. {
2768. ch->GetSectree()->ForEachAround(f);
2769. // 2. Shoot!
2770. if (f.GetVictim())
2771. {
2772. ch->CreateFly(FLY_SKILL_MUYEONG, f.GetVictim());
2773. ch->ComputeSkill(SKILL_MUYEONG, f.GetVictim());
2774. }
2775. }
2777. return PASSES_PER_SEC(3);
2778. }
2780. void CHARACTER::StartMuyeongEvent()
2781. {
2782. if (m_pkMuyeongEvent)
2783. return;
2785. char_event_info* info = AllocEventInfo<char_event_info>();
2787. info->ch = this;
2788. m_pkMuyeongEvent = event_create(skill_muyoung_event, info, PASSES_PER_SEC(1));
2789. }
2791. void CHARACTER::StopMuyeongEvent()
2792. {
2793. event_cancel(&m_pkMuyeongEvent);
2794. }
2796. void CHARACTER::SkillLearnWaitMoreTimeMessage(DWORD ms)
2797. {
2798. //const char* str = "";
2799. //
2800. if (ms < 3 * 60)
2801. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¸ö ¼ÓÀÌ ¶ß°Ì±º. ÇÏÁö¸¸ ¾ÆÁÖ Æí¾ÈÇØ. ÀÌ´ë·Î ±â¸¦ ¾ÈÁ¤½ÃÅ°ÀÚ."));
2802. else if (ms < 5 * 60)
2803. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("±×·¡, õõÈ÷. Á»´õ õõÈ÷, ±×·¯³ª ¸·Èû ¾øÀÌ ºü¸£°Ô!"));
2804. else if (ms < 10 * 60) // 10ºÐ
2805. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("±×·¡, ÀÌ ´À³¦À̾ß. ü³»¿¡ ±â°¡ ¾ÆÁÖ Ã游ÇØ."));
2806. else if (ms < 30 * 60) // 30ºÐ
2807. {
2808. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("´Ù Àоú´Ù! ÀÌÁ¦ ºñ±Þ¿¡ ÀûÇôÀÖ´Â ´ë·Î Àü½Å¿¡ ±â¸¦ µ¹¸®±â¸¸ Çϸé,"));
2809. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("±×°ÍÀ¸·Î ¼ö·ÃÀº ³¡³­ °Å¾ß!"));
2810. }
2811. else if (ms < 1 * 3600) // 1½Ã°£
2812. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÀÌÁ¦ Ã¥ÀÇ ¸¶Áö¸· ÀåÀ̾ß! ¼ö·ÃÀÇ ³¡ÀÌ ´«¿¡ º¸ÀÌ°í ÀÖ¾î!"));
2813. else if (ms < 2 * 3600) // 2½Ã°£
2814. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¾ó¸¶ ¾È ³²¾Ò¾î! Á¶±Ý¸¸ ´õ!"));
2815. else if (ms < 3 * 3600)
2816. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÁÁ¾Ò¾î! Á¶±Ý¸¸ ´õ ÀÐÀ¸¸é ³¡ÀÌ´Ù!"));
2817. else if (ms < 6 * 3600)
2818. {
2819. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("Ã¥Àåµµ ÀÌÁ¦ ¾ó¸¶ ³²Áö ¾Ê¾Ò±º."));
2820. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¹º°¡ ¸ö ¾È¿¡ ÈûÀÌ »ý±â´Â ±âºÐÀÎ °É."));
2821. }
2822. else if (ms < 12 * 3600)
2823. {
2824. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÀÌÁ¦ Á» ½½½½ °¡´ÚÀÌ ÀâÈ÷´Â °Í °°Àºµ¥."));
2825. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÁÁ¾Æ, ÀÌ ±â¼¼·Î °è¼Ó ³ª°£´Ù!"));
2826. }
2827. else if (ms < 18 * 3600)
2828. {
2829. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¾Æ´Ï ¾î¶»°Ô µÈ °Ô Á¾ÀÏ Àо ¸Ó¸®¿¡ ¾È µé¾î¿À³Ä."));
2830. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("°øºÎÇϱ⠽ȾîÁö³×."));
2831. }
2832. else //if (ms < 2 * 86400)
2833. {
2834. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("»ý°¢¸¸Å­ ÀбⰡ ½±Áö°¡ ¾Ê±º. ÀÌÇصµ ¾î·Æ°í ³»¿ëµµ ³­ÇØÇØ."));
2835. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÀÌ·¡¼­¾ß °øºÎ°¡ ¾ÈµÈ´Ù±¸."));
2836. }
2837. /*
2838. str = "30%";
2839. else if (ms < 3 * 86400)
2840. str = "10%";
2841. else if (ms < 4 * 86400)
2842. str = "5%";
2843. else
2844. str = "0%";*/
2846. //ChatPacket(CHAT_TYPE_TALKING, "%s", str);
2847. }
2849. void CHARACTER::DisableCooltime()
2850. {
2851. m_bDisableCooltime = true;
2852. }
2854. bool CHARACTER::HasMobSkill() const
2855. {
2856. return CountMobSkill() > 0;
2857. }
2859. size_t CHARACTER::CountMobSkill() const
2860. {
2861. if (!m_pkMobData)
2862. return 0;
2864. size_t c = 0;
2866. for (size_t i = 0; i < MOB_SKILL_MAX_NUM; ++i)
2867. if (m_pkMobData->m_table.Skills[i].dwVnum)
2868. ++c;
2870. return c;
2871. }
2873. const TMobSkillInfo* CHARACTER::GetMobSkill(unsigned int idx) const
2874. {
2875. if (idx >= MOB_SKILL_MAX_NUM)
2876. return NULL;
2878. if (!m_pkMobData)
2879. return NULL;
2881. if (0 == m_pkMobData->m_table.Skills[idx].dwVnum)
2882. return NULL;
2884. return &m_pkMobData->m_mobSkillInfo[idx];
2885. }
2887. bool CHARACTER::CanUseMobSkill(unsigned int idx) const
2888. {
2889. const TMobSkillInfo* pInfo = GetMobSkill(idx);
2891. if (!pInfo)
2892. return false;
2894. if (m_adwMobSkillCooltime[idx] > get_dword_time())
2895. return false;
2897. if (number(0, 1))
2898. return false;
2900. return true;
2901. }
2903. EVENTINFO(mob_skill_event_info)
2904. {
2905. DynamicCharacterPtr ch;
2906. PIXEL_POSITION pos;
2907. DWORD vnum;
2908. int index;
2909. BYTE level;
2911. mob_skill_event_info()
2912. : ch()
2913. , pos()
2914. , vnum(0)
2915. , index(0)
2916. , level(0)
2917. {
2918. }
2919. };
2921. EVENTFUNC(mob_skill_hit_event)
2922. {
2923. mob_skill_event_info * info = dynamic_cast<mob_skill_event_info *>( event->info );
2925. if ( info == NULL )
2926. {
2927. sys_err( "mob_skill_event_info> <Factor> Null pointer" );
2928. return 0;
2929. }
2931. // <Factor>
2932. LPCHARACTER ch = info->ch;
2933. if (ch == NULL) {
2934. return 0;
2935. }
2937. ch->ComputeSkillAtPosition(info->vnum, info->pos, info->level);
2938. ch->m_mapMobSkillEvent.erase(info->index);
2940. return 0;
2941. }
2943. bool CHARACTER::UseMobSkill(unsigned int idx)
2944. {
2945. if (IsPC())
2946. return false;
2948. const TMobSkillInfo* pInfo = GetMobSkill(idx);
2950. if (!pInfo)
2951. return false;
2953. DWORD dwVnum = pInfo->dwSkillVnum;
2954. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
2956. if (!pkSk)
2957. return false;
2959. const float k = 1.0 * GetSkillPower(pkSk->dwVnum, pInfo->bSkillLevel) * pkSk->bMaxLevel / 100;
2961. pkSk->kCooldownPoly.SetVar("k", k);
2962. int iCooltime = (int) (pkSk->kCooldownPoly.Eval() * 1000);
2964. m_adwMobSkillCooltime[idx] = get_dword_time() + iCooltime;
2966. sys_log(0, "USE_MOB_SKILL: %s idx %d vnum %u cooltime %d", GetName(), idx, dwVnum, iCooltime);
2968. if (m_pkMobData->m_mobSkillInfo[idx].vecSplashAttack.empty())
2969. {
2970. sys_err("No skill hit data for mob %s index %d", GetName(), idx);
2971. return false;
2972. }
2974. for (size_t i = 0; i < m_pkMobData->m_mobSkillInfo[idx].vecSplashAttack.size(); i++)
2975. {
2976. PIXEL_POSITION pos = GetXYZ();
2977. const TMobSplashAttackInfo& rInfo = m_pkMobData->m_mobSkillInfo[idx].vecSplashAttack[i];
2979. if (rInfo.dwHitDistance)
2980. {
2981. float fx, fy;
2982. GetDeltaByDegree(GetRotation(), rInfo.dwHitDistance, &fx, &fy);
2983. pos.x += (long) fx;
2984. pos.y += (long) fy;
2985. }
2987. if (rInfo.dwTiming)
2988. {
2989. if (test_server)
2990. sys_log(0, " timing %ums", rInfo.dwTiming);
2992. mob_skill_event_info* info = AllocEventInfo<mob_skill_event_info>();
2994. info->ch = this;
2995. info->pos = pos;
2996. info->level = pInfo->bSkillLevel;
2997. info->vnum = dwVnum;
2998. info->index = i;
3000. // <Factor> Cancel existing event first
3001. itertype(m_mapMobSkillEvent) it = m_mapMobSkillEvent.find(i);
3002. if (it != m_mapMobSkillEvent.end()) {
3003. LPEVENT existing = it->second;
3004. event_cancel(&existing);
3005. m_mapMobSkillEvent.erase(it);
3006. }
3008. m_mapMobSkillEvent.insert(std::make_pair(i, event_create(mob_skill_hit_event, info, PASSES_PER_SEC(rInfo.dwTiming) / 1000)));
3009. }
3010. else
3011. {
3012. ComputeSkillAtPosition(dwVnum, pos, pInfo->bSkillLevel);
3013. }
3014. }
3016. return true;
3017. }
3019. void CHARACTER::ResetMobSkillCooltime()
3020. {
3021. memset(m_adwMobSkillCooltime, 0, sizeof(m_adwMobSkillCooltime));
3022. }
3024. bool CHARACTER::IsUsableSkillMotion(DWORD dwMotionIndex) const
3025. {
3026. DWORD selfJobGroup = (GetJob()+1) * 10 + GetSkillGroup();
3028. const DWORD SKILL_NUM = 158;
3029. static DWORD s_anSkill2JobGroup[SKILL_NUM] = {
3030. 0, // common_skill 0
3031. 11, // job_skill 1
3032. 11, // job_skill 2
3033. 11, // job_skill 3
3034. 11, // job_skill 4
3035. 11, // job_skill 5
3036. 11, // job_skill 6
3037. 0, // common_skill 7
3038. 0, // common_skill 8
3039. 0, // common_skill 9
3040. 0, // common_skill 10
3041. 0, // common_skill 11
3042. 0, // common_skill 12
3043. 0, // common_skill 13
3044. 0, // common_skill 14
3045. 0, // common_skill 15
3046. 12, // job_skill 16
3047. 12, // job_skill 17
3048. 12, // job_skill 18
3049. 12, // job_skill 19
3050. 12, // job_skill 20
3051. 12, // job_skill 21
3052. 0, // common_skill 22
3053. 0, // common_skill 23
3054. 0, // common_skill 24
3055. 0, // common_skill 25
3056. 0, // common_skill 26
3057. 0, // common_skill 27
3058. 0, // common_skill 28
3059. 0, // common_skill 29
3060. 0, // common_skill 30
3061. 21, // job_skill 31
3062. 21, // job_skill 32
3063. 21, // job_skill 33
3064. 21, // job_skill 34
3065. 21, // job_skill 35
3066. 21, // job_skill 36
3067. 0, // common_skill 37
3068. 0, // common_skill 38
3069. 0, // common_skill 39
3070. 0, // common_skill 40
3071. 0, // common_skill 41
3072. 0, // common_skill 42
3073. 0, // common_skill 43
3074. 0, // common_skill 44
3075. 0, // common_skill 45
3076. 22, // job_skill 46
3077. 22, // job_skill 47
3078. 22, // job_skill 48
3079. 22, // job_skill 49
3080. 22, // job_skill 50
3081. 22, // job_skill 51
3082. 0, // common_skill 52
3083. 0, // common_skill 53
3084. 0, // common_skill 54
3085. 0, // common_skill 55
3086. 0, // common_skill 56
3087. 0, // common_skill 57
3088. 0, // common_skill 58
3089. 0, // common_skill 59
3090. 0, // common_skill 60
3091. 31, // job_skill 61
3092. 31, // job_skill 62
3093. 31, // job_skill 63
3094. 31, // job_skill 64
3095. 31, // job_skill 65
3096. 31, // job_skill 66
3097. 0, // common_skill 67
3098. 0, // common_skill 68
3099. 0, // common_skill 69
3100. 0, // common_skill 70
3101. 0, // common_skill 71
3102. 0, // common_skill 72
3103. 0, // common_skill 73
3104. 0, // common_skill 74
3105. 0, // common_skill 75
3106. 32, // job_skill 76
3107. 32, // job_skill 77
3108. 32, // job_skill 78
3109. 32, // job_skill 79
3110. 32, // job_skill 80
3111. 32, // job_skill 81
3112. 0, // common_skill 82
3113. 0, // common_skill 83
3114. 0, // common_skill 84
3115. 0, // common_skill 85
3116. 0, // common_skill 86
3117. 0, // common_skill 87
3118. 0, // common_skill 88
3119. 0, // common_skill 89
3120. 0, // common_skill 90
3121. 41, // job_skill 91
3122. 41, // job_skill 92
3123. 41, // job_skill 93
3124. 41, // job_skill 94
3125. 41, // job_skill 95
3126. 41, // job_skill 96
3127. 0, // common_skill 97
3128. 0, // common_skill 98
3129. 0, // common_skill 99
3130. 0, // common_skill 100
3131. 0, // common_skill 101
3132. 0, // common_skill 102
3133. 0, // common_skill 103
3134. 0, // common_skill 104
3135. 0, // common_skill 105
3136. 42, // job_skill 106
3137. 42, // job_skill 107
3138. 42, // job_skill 108
3139. 42, // job_skill 109
3140. 42, // job_skill 110
3141. 42, // job_skill 111
3142. 0, // common_skill 112
3143. 0, // common_skill 113
3144. 0, // common_skill 114
3145. 0, // common_skill 115
3146. 0, // common_skill 116
3147. 0, // common_skill 117
3148. 0, // common_skill 118
3149. 0, // common_skill 119
3150. 0, // common_skill 120
3151. 0, // common_skill 121
3152. 0, // common_skill 122
3153. 0, // common_skill 123
3154. 0, // common_skill 124
3155. 0, // common_skill 125
3156. 0, // common_skill 126
3157. 0, // common_skill 127
3158. 0, // common_skill 128
3159. 0, // common_skill 129
3160. 0, // common_skill 130
3161. 0, // common_skill 131
3162. 0, // common_skill 132
3163. 0, // common_skill 133
3164. 0, // common_skill 134
3165. 0, // common_skill 135
3166. 0, // common_skill 136
3167. 0, // job_skill 137
3168. 0, // job_skill 138
3169. 0, // job_skill 139
3170. 0, // job_skill 140
3171. 0, // common_skill 141
3172. 0, // common_skill 142
3173. 0, // common_skill 143
3174. 0, // common_skill 144
3175. 0, // common_skill 145
3176. 0, // common_skill 146
3177. 0, // common_skill 147
3178. 0, // common_skill 148
3179. 0, // common_skill 149
3180. 0, // common_skill 150
3181. 0, // common_skill 151
3182. 0, // job_skill 152
3183. 0, // job_skill 153
3184. 0, // job_skill 154
3185. 0, // job_skill 155
3186. 0, // job_skill 156
3187. 0, // job_skill 157
3188. }; // s_anSkill2JobGroup
3190. const DWORD MOTION_MAX_NUM = 124;
3191. const DWORD SKILL_LIST_MAX_COUNT = 5;
3193. static DWORD s_anMotion2SkillVnumList[MOTION_MAX_NUM][SKILL_LIST_MAX_COUNT] =
3194. {
3195. // ½ºÅ³¼ö ¹«»ç½ºÅ³ID ÀÚ°´½ºÅ³ID ¼ö¶ó½ºÅ³ID ¹«´ç½ºÅ³ID
3196. { 0, 0, 0, 0, 0 }, // 0
3198. // 1¹ø Á÷±º ±âº» ½ºÅ³
3199. { 4, 1, 31, 61, 91 }, // 1
3200. { 4, 2, 32, 62, 92 }, // 2
3201. { 4, 3, 33, 63, 93 }, // 3
3202. { 4, 4, 34, 64, 94 }, // 4
3203. { 4, 5, 35, 65, 95 }, // 5
3204. { 4, 6, 36, 66, 96 }, // 6
3205. { 0, 0, 0, 0, 0 }, // 7
3206. { 0, 0, 0, 0, 0 }, // 8
3207. // 1¹ø Á÷±º ±âº» ½ºÅ³ ³¡
3209. // ¿©À¯ºÐ
3210. { 0, 0, 0, 0, 0 }, // 9
3211. { 0, 0, 0, 0, 0 }, // 10
3212. { 0, 0, 0, 0, 0 }, // 11
3213. { 0, 0, 0, 0, 0 }, // 12
3214. { 0, 0, 0, 0, 0 }, // 13
3215. { 0, 0, 0, 0, 0 }, // 14
3216. { 0, 0, 0, 0, 0 }, // 15
3217. // ¿©À¯ºÐ ³¡
3219. // 2¹ø Á÷±º ±âº» ½ºÅ³
3220. { 4, 16, 46, 76, 106 }, // 16
3221. { 4, 17, 47, 77, 107 }, // 17
3222. { 4, 18, 48, 78, 108 }, // 18
3223. { 4, 19, 49, 79, 109 }, // 19
3224. { 4, 20, 50, 80, 110 }, // 20
3225. { 4, 21, 51, 81, 111 }, // 21
3226. { 0, 0, 0, 0, 0 }, // 22
3227. { 0, 0, 0, 0, 0 }, // 23
3228. // 2¹ø Á÷±º ±âº» ½ºÅ³ ³¡
3230. // ¿©À¯ºÐ
3231. { 0, 0, 0, 0, 0 }, // 24
3232. { 0, 0, 0, 0, 0 }, // 25
3233. // ¿©À¯ºÐ ³¡
3235. // 1¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³
3236. { 4, 1, 31, 61, 91 }, // 26
3237. { 4, 2, 32, 62, 92 }, // 27
3238. { 4, 3, 33, 63, 93 }, // 28
3239. { 4, 4, 34, 64, 94 }, // 29
3240. { 4, 5, 35, 65, 95 }, // 30
3241. { 4, 6, 36, 66, 96 }, // 31
3242. { 0, 0, 0, 0, 0 }, // 32
3243. { 0, 0, 0, 0, 0 }, // 33
3244. // 1¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³ ³¡
3246. // ¿©À¯ºÐ
3247. { 0, 0, 0, 0, 0 }, // 34
3248. { 0, 0, 0, 0, 0 }, // 35
3249. { 0, 0, 0, 0, 0 }, // 36
3250. { 0, 0, 0, 0, 0 }, // 37
3251. { 0, 0, 0, 0, 0 }, // 38
3252. { 0, 0, 0, 0, 0 }, // 39
3253. { 0, 0, 0, 0, 0 }, // 40
3254. // ¿©À¯ºÐ ³¡
3256. // 2¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³
3257. { 4, 16, 46, 76, 106 }, // 41
3258. { 4, 17, 47, 77, 107 }, // 42
3259. { 4, 18, 48, 78, 108 }, // 43
3260. { 4, 19, 49, 79, 109 }, // 44
3261. { 4, 20, 50, 80, 110 }, // 45
3262. { 4, 21, 51, 81, 111 }, // 46
3263. { 0, 0, 0, 0, 0 }, // 47
3264. { 0, 0, 0, 0, 0 }, // 48
3265. // 2¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³ ³¡
3267. // ¿©À¯ºÐ
3268. { 0, 0, 0, 0, 0 }, // 49
3269. { 0, 0, 0, 0, 0 }, // 50
3270. // ¿©À¯ºÐ ³¡
3272. // 1¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³
3273. { 4, 1, 31, 61, 91 }, // 51
3274. { 4, 2, 32, 62, 92 }, // 52
3275. { 4, 3, 33, 63, 93 }, // 53
3276. { 4, 4, 34, 64, 94 }, // 54
3277. { 4, 5, 35, 65, 95 }, // 55
3278. { 4, 6, 36, 66, 96 }, // 56
3279. { 0, 0, 0, 0, 0 }, // 57
3280. { 0, 0, 0, 0, 0 }, // 58
3281. // 1¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³ ³¡
3283. // ¿©À¯ºÐ
3284. { 0, 0, 0, 0, 0 }, // 59
3285. { 0, 0, 0, 0, 0 }, // 60
3286. { 0, 0, 0, 0, 0 }, // 61
3287. { 0, 0, 0, 0, 0 }, // 62
3288. { 0, 0, 0, 0, 0 }, // 63
3289. { 0, 0, 0, 0, 0 }, // 64
3290. { 0, 0, 0, 0, 0 }, // 65
3291. // ¿©À¯ºÐ ³¡
3293. // 2¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³
3294. { 4, 16, 46, 76, 106 }, // 66
3295. { 4, 17, 47, 77, 107 }, // 67
3296. { 4, 18, 48, 78, 108 }, // 68
3297. { 4, 19, 49, 79, 109 }, // 69
3298. { 4, 20, 50, 80, 110 }, // 70
3299. { 4, 21, 51, 81, 111 }, // 71
3300. { 0, 0, 0, 0, 0 }, // 72
3301. { 0, 0, 0, 0, 0 }, // 73
3302. // 2¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³ ³¡
3304. //¿©À¯ºÐ
3305. { 0, 0, 0, 0, 0 }, // 74
3306. { 0, 0, 0, 0, 0 }, // 75
3307. // ¿©À¯ºÐ ³¡
3309. // 1¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³
3310. { 4, 1, 31, 61, 91 }, // 76
3311. { 4, 2, 32, 62, 92 }, // 77
3312. { 4, 3, 33, 63, 93 }, // 78
3313. { 4, 4, 34, 64, 94 }, // 79
3314. { 4, 5, 35, 65, 95 }, // 80
3315. { 4, 6, 36, 66, 96 }, // 81
3316. { 0, 0, 0, 0, 0 }, // 82
3317. { 0, 0, 0, 0, 0 }, // 83
3318. // 1¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³ ³¡
3320. // ¿©À¯ºÐ
3321. { 0, 0, 0, 0, 0 }, // 84
3322. { 0, 0, 0, 0, 0 }, // 85
3323. { 0, 0, 0, 0, 0 }, // 86
3324. { 0, 0, 0, 0, 0 }, // 87
3325. { 0, 0, 0, 0, 0 }, // 88
3326. { 0, 0, 0, 0, 0 }, // 89
3327. { 0, 0, 0, 0, 0 }, // 90
3328. // ¿©À¯ºÐ ³¡
3330. // 2¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³
3331. { 4, 16, 46, 76, 106 }, // 91
3332. { 4, 17, 47, 77, 107 }, // 92
3333. { 4, 18, 48, 78, 108 }, // 93
3334. { 4, 19, 49, 79, 109 }, // 94
3335. { 4, 20, 50, 80, 110 }, // 95
3336. { 4, 21, 51, 81, 111 }, // 96
3337. { 0, 0, 0, 0, 0 }, // 97
3338. { 0, 0, 0, 0, 0 }, // 98
3339. // 2¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³ ³¡
3341. // ¿©À¯ºÐ
3342. { 0, 0, 0, 0, 0 }, // 99
3343. { 0, 0, 0, 0, 0 }, // 100
3344. // ¿©À¯ºÐ ³¡
3346. // ±æµå ½ºÅ³
3347. { 1, 152, 0, 0, 0}, // 101
3348. { 1, 153, 0, 0, 0}, // 102
3349. { 1, 154, 0, 0, 0}, // 103
3350. { 1, 155, 0, 0, 0}, // 104
3351. { 1, 156, 0, 0, 0}, // 105
3352. { 1, 157, 0, 0, 0}, // 106
3353. // ±æµå ½ºÅ³ ³¡
3355. // ¿©À¯ºÐ
3356. { 0, 0, 0, 0, 0}, // 107
3357. { 0, 0, 0, 0, 0}, // 108
3358. { 0, 0, 0, 0, 0}, // 109
3359. { 0, 0, 0, 0, 0}, // 110
3360. { 0, 0, 0, 0, 0}, // 111
3361. { 0, 0, 0, 0, 0}, // 112
3362. { 0, 0, 0, 0, 0}, // 113
3363. { 0, 0, 0, 0, 0}, // 114
3364. { 0, 0, 0, 0, 0}, // 115
3365. { 0, 0, 0, 0, 0}, // 116
3366. { 0, 0, 0, 0, 0}, // 117
3367. { 0, 0, 0, 0, 0}, // 118
3368. { 0, 0, 0, 0, 0}, // 119
3369. { 0, 0, 0, 0, 0}, // 120
3370. // ¿©À¯ºÐ ³¡
3372. // ½Â¸¶ ½ºÅ³
3373. { 2, 137, 140, 0, 0}, // 121
3374. { 1, 138, 0, 0, 0}, // 122
3375. { 1, 139, 0, 0, 0}, // 123
3376. // ½Â¸¶ ½ºÅ³ ³¡
3377. };
3379. if (dwMotionIndex >= MOTION_MAX_NUM)
3380. {
3381. sys_err("OUT_OF_MOTION_VNUM: name=%s, motion=%d/%d", GetName(), dwMotionIndex, MOTION_MAX_NUM);
3382. return false;
3383. }
3385. DWORD* skillVNums = s_anMotion2SkillVnumList[dwMotionIndex];
3387. DWORD skillCount = *skillVNums++;
3388. if (skillCount >= SKILL_LIST_MAX_COUNT)
3389. {
3390. sys_err("OUT_OF_SKILL_LIST: name=%s, count=%d/%d", GetName(), skillCount, SKILL_LIST_MAX_COUNT);
3391. return false;
3392. }
3394. for (DWORD skillIndex = 0; skillIndex != skillCount; ++skillIndex)
3395. {
3396. if (skillIndex >= SKILL_MAX_NUM)
3397. {
3398. sys_err("OUT_OF_SKILL_VNUM: name=%s, skill=%d/%d", GetName(), skillIndex, SKILL_MAX_NUM);
3399. return false;
3400. }
3402. DWORD eachSkillVNum = skillVNums[skillIndex];
3403. if ( eachSkillVNum != 0 )
3404. {
3405. DWORD eachJobGroup = s_anSkill2JobGroup[eachSkillVNum];
3407. if (0 == eachJobGroup || eachJobGroup == selfJobGroup)
3408. {
3409. // GUILDSKILL_BUG_FIX
3410. DWORD eachSkillLevel = 0;
3412. if (eachSkillVNum >= GUILD_SKILL_START && eachSkillVNum <= GUILD_SKILL_END)
3413. {
3414. if (GetGuild())
3415. eachSkillLevel = GetGuild()->GetSkillLevel(eachSkillVNum);
3416. else
3417. eachSkillLevel = 0;
3418. }
3419. else
3420. {
3421. eachSkillLevel = GetSkillLevel(eachSkillVNum);
3422. }
3424. if (eachSkillLevel > 0)
3425. {
3426. return true;
3427. }
3428. // END_OF_GUILDSKILL_BUG_FIX
3429. }
3430. }
3431. }
3433. return false;
3434. }
3436. void CHARACTER::ClearSkill()
3437. {
3438. PointChange(POINT_SKILL, 4 + (GetLevel() - 5) - GetPoint(POINT_SKILL));
3440. ResetSkill();
3441. }
3443. void CHARACTER::ClearSubSkill()
3444. {
3445. PointChange(POINT_SUB_SKILL, GetLevel() < 10 ? 0 : (GetLevel() - 9) - GetPoint(POINT_SUB_SKILL));
3447. if (m_pSkillLevels == NULL)
3448. {
3449. sys_err("m_pSkillLevels nil (name: %s)", GetName());
3450. return;
3451. }
3453. TPlayerSkill CleanSkill;
3454. memset(&CleanSkill, 0, sizeof(TPlayerSkill));
3456. size_t count = sizeof(s_adwSubSkillVnums) / sizeof(s_adwSubSkillVnums[0]);
3458. for (size_t i = 0; i < count; ++i)
3459. {
3460. if (s_adwSubSkillVnums[i] >= SKILL_MAX_NUM)
3461. continue;
3463. m_pSkillLevels[s_adwSubSkillVnums[i]] = CleanSkill;
3464. }
3466. ComputePoints();
3467. SkillLevelPacket();
3468. }
3470. bool CHARACTER::ResetOneSkill(DWORD dwVnum)
3471. {
3472. if (NULL == m_pSkillLevels)
3473. {
3474. sys_err("m_pSkillLevels nil (name %s, vnum %u)", GetName(), dwVnum);
3475. return false;
3476. }
3478. if (dwVnum >= SKILL_MAX_NUM)
3479. {
3480. sys_err("vnum overflow (name %s, vnum %u)", GetName(), dwVnum);
3481. return false;
3482. }
3484. BYTE level = m_pSkillLevels[dwVnum].bLevel;
3486. m_pSkillLevels[dwVnum].bLevel = 0;
3487. m_pSkillLevels[dwVnum].bMasterType = 0;
3488. m_pSkillLevels[dwVnum].tNextRead = 0;
3490. if (level > 17)
3491. level = 17;
3493. PointChange(POINT_SKILL, level);
3495. LogManager::instance().CharLog(this, dwVnum, "ONE_SKILL_RESET_BY_SCROLL", "");
3497. ComputePoints();
3498. SkillLevelPacket();
3500. return true;
3501. }
3503. bool CHARACTER::CanUseSkill(DWORD dwSkillVnum) const
3504. {
3505. if (0 == dwSkillVnum) return false;
3507. if (0 < GetSkillGroup())
3508. {
3509. const int SKILL_COUNT = 6;
3510. static const DWORD SkillList[JOB_MAX_NUM][SKILL_GROUP_MAX_NUM][SKILL_COUNT] =
3511. {
3512. { { 1, 2, 3, 4, 5, 6 }, { 16, 17, 18, 19, 20, 21 } },
3513. { { 31, 32, 33, 34, 35, 36 }, { 46, 47, 48, 49, 50, 51 } },
3514. { { 61, 62, 63, 64, 65, 66 }, { 76, 77, 78, 79, 80, 81 } },
3515. { { 91, 92, 93, 94, 95, 96 }, { 106,107,108,109,110,111 } },
3516. };
3518. const DWORD* pSkill = SkillList[ GetJob() ][ GetSkillGroup()-1 ];
3520. for (int i=0 ; i < SKILL_COUNT ; ++i)
3521. {
3522. if (pSkill[i] == dwSkillVnum) return true;
3523. }
3524. }
3526. //if (true == IsHorseRiding())
3528. if (true == IsRiding())
3529. {
3530. //¸¶¿îÆ® Å»°ÍÁß °í±Þ¸»¸¸ ½ºÅ³ »ç¿ë°¡´É
3531. if(GetMountVnum())
3532. {
3533. if( !((GetMountVnum() >= 20209 && GetMountVnum() <= 20212) ||
3534. GetMountVnum() == 20215 || GetMountVnum() == 20218 || GetMountVnum() == 20225 ) )
3535. return false;
3536. }
3538. switch(dwSkillVnum)
3539. {
3540. case SKILL_HORSE_WILDATTACK:
3541. case SKILL_HORSE_CHARGE:
3542. case SKILL_HORSE_ESCAPE:
3543. case SKILL_HORSE_WILDATTACK_RANGE:
3544. return true;
3545. }
3546. }
3548. switch( dwSkillVnum )
3549. {
3550. case 121: case 122: case 124: case 126: case 127: case 128: case 129: case 130:
3551. case 131:
3552. case 151: case 152: case 153: case 154: case 155: case 156: case 157: case 158: case 159:
3553. return true;
3554. }
3556. return false;
3557. }
3559. bool CHARACTER::CheckSkillHitCount(const BYTE SkillID, const VID TargetVID)
3560. {
3561. std::map<int, TSkillUseInfo>::iterator iter = m_SkillUseInfo.find(SkillID);
3563. if (iter == m_SkillUseInfo.end())
3564. {
3565. sys_log(0, "SkillHack: Skill(%u) is not in container", SkillID);
3566. return false;
3567. }
3569. TSkillUseInfo& rSkillUseInfo = iter->second;
3571. if (false == rSkillUseInfo.bUsed)
3572. {
3573. sys_log(0, "SkillHack: not used skill(%u)", SkillID);
3574. return false;
3575. }
3577. switch (SkillID)
3578. {
3579. case SKILL_YONGKWON:
3580. case SKILL_HWAYEOMPOK:
3581. case SKILL_DAEJINGAK:
3582. case SKILL_PAERYONG:
3583. sys_log(0, "SkillHack: cannot use attack packet for skill(%u)", SkillID);
3584. return false;
3585. }
3587. boost::unordered_map<VID, size_t>::iterator iterTargetMap = rSkillUseInfo.TargetVIDMap.find(TargetVID);
3589. if (rSkillUseInfo.TargetVIDMap.end() != iterTargetMap)
3590. {
3591. size_t MaxAttackCountPerTarget = 1;
3593. switch (SkillID)
3594. {
3595. case SKILL_SAMYEON:
3596. case SKILL_CHARYUN:
3597. MaxAttackCountPerTarget = 3;
3598. break;
3600. case SKILL_HORSE_WILDATTACK_RANGE:
3601. MaxAttackCountPerTarget = 5;
3602. break;
3604. case SKILL_YEONSA:
3605. MaxAttackCountPerTarget = 7;
3606. break;
3608. case SKILL_HORSE_ESCAPE:
3609. MaxAttackCountPerTarget = 10;
3610. break;
3611. }
3613. if (iterTargetMap->second >= MaxAttackCountPerTarget)
3614. {
3615. sys_log(0, "SkillHack: Too Many Hit count from SkillID(%u) count(%u)", SkillID, iterTargetMap->second);
3616. return false;
3617. }
3619. iterTargetMap->second++;
3620. }
3621. else
3622. {
3623. rSkillUseInfo.TargetVIDMap.insert( std::make_pair(TargetVID, 1) );
3624. }
3626. return true;
3627. }

char_skill.cpp