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"
  24. #include "../../common/CommonDefines.h"
  26. #define ENABLE_FORCE2MASTERSKILL
  27. // #define ENABLE_MOUNTSKILL_CHECK
  28. // #define ENABLE_NULLIFYAFFECT_LIMIT
  30. static const DWORD s_adwSubSkillVnums[] =
  31. {
  32. SKILL_LEADERSHIP,
  33. SKILL_COMBO,
  34. SKILL_MINING,
  35. SKILL_LANGUAGE1,
  36. SKILL_LANGUAGE2,
  37. SKILL_LANGUAGE3,
  38. SKILL_POLYMORPH,
  39. SKILL_HORSE,
  40. SKILL_HORSE_SUMMON,
  41. SKILL_HORSE_WILDATTACK,
  42. SKILL_HORSE_CHARGE,
  43. SKILL_HORSE_ESCAPE,
  44. SKILL_HORSE_WILDATTACK_RANGE,
  45. SKILL_ADD_HP,
  46. SKILL_RESIST_PENETRATE
  47. };
  49. time_t CHARACTER::GetSkillNextReadTime(DWORD dwVnum) const
  50. {
  51. if (dwVnum >= SKILL_MAX_NUM)
  52. {
  53. sys_err("vnum overflow (vnum: %u)", dwVnum);
  54. return 0;
  55. }
  57. return m_pSkillLevels ? m_pSkillLevels[dwVnum].tNextRead : 0;
  58. }
  60. void CHARACTER::SetSkillNextReadTime(DWORD dwVnum, time_t time)
  61. {
  62. if (m_pSkillLevels && dwVnum < SKILL_MAX_NUM)
  63. m_pSkillLevels[dwVnum].tNextRead = time;
  64. }
  66. bool TSkillUseInfo::HitOnce(DWORD dwVnum)
  67. {
  68. // ¾²Áöµµ¾Ê¾ÒÀ¸¸é ¶§¸®Áöµµ ¸øÇÑ´Ù.
  69. if (!bUsed)
  70. return false;
  72. sys_log(1, "__HitOnce NextUse %u current %u count %d scount %d", dwNextSkillUsableTime, get_dword_time(), iHitCount, iSplashCount);
  74. if (dwNextSkillUsableTime && dwNextSkillUsableTime<get_dword_time() && dwVnum != SKILL_MUYEONG && dwVnum != SKILL_HORSE_WILDATTACK)
  75. {
  76. sys_log(1, "__HitOnce can't hit");
  78. return false;
  79. }
  81. if (iHitCount == -1)
  82. {
  83. sys_log(1, "__HitOnce OK %d %d %d", dwNextSkillUsableTime, get_dword_time(), iHitCount);
  84. return true;
  85. }
  87. if (iHitCount)
  88. {
  89. sys_log(1, "__HitOnce OK %d %d %d", dwNextSkillUsableTime, get_dword_time(), iHitCount);
  90. iHitCount--;
  91. return true;
  92. }
  93. return false;
  94. }
  98. bool TSkillUseInfo::UseSkill(bool isGrandMaster, DWORD vid, DWORD dwCooltime, int splashcount, int hitcount, int range)
  99. {
  100. this->isGrandMaster = isGrandMaster;
  101. DWORD dwCur = get_dword_time();
  103. // ¾ÆÁ÷ ÄğŸÀÓÀÌ ³¡³ªÁö ¾Ê¾Ò´Ù.
  104. if (bUsed && dwNextSkillUsableTime > dwCur)
  105. {
  106. sys_log(0, "cooltime is not over delta %u", dwNextSkillUsableTime - dwCur);
  107. iHitCount = 0;
  108. return false;
  109. }
  111. bUsed = true;
  113. if (dwCooltime)
  114. dwNextSkillUsableTime = dwCur + dwCooltime;
  115. else
  116. dwNextSkillUsableTime = 0;
  118. iRange = range;
  119. iMaxHitCount = iHitCount = hitcount;
  121. if (test_server)
  122. sys_log(0, "UseSkill NextUse %u current %u cooltime %d hitcount %d/%d", dwNextSkillUsableTime, dwCur, dwCooltime, iHitCount, iMaxHitCount);
  124. dwVID = vid;
  125. iSplashCount = splashcount;
  126. return true;
  127. }
  129. int CHARACTER::GetChainLightningMaxCount() const
  130. {
  131. return aiChainLightningCountBySkillLevel[MIN(SKILL_MAX_LEVEL, GetSkillLevel(SKILL_CHAIN))];
  132. }
  134. void CHARACTER::SetAffectedEunhyung()
  135. {
  136. m_dwAffectedEunhyungLevel = GetSkillPower(SKILL_EUNHYUNG);
  137. }
  139. void CHARACTER::SetSkillGroup(BYTE bSkillGroup)
  140. {
  141. if (bSkillGroup > 2)
  142. return;
  144. if (GetLevel() < 5)
  145. return;
  147. m_points.skill_group = bSkillGroup;
  149. TPacketGCChangeSkillGroup p;
  150. p.header = HEADER_GC_SKILL_GROUP;
  151. p.skill_group = m_points.skill_group;
  153. GetDesc()->Packet(&p, sizeof(TPacketGCChangeSkillGroup));
  154. }
  156. int CHARACTER::ComputeCooltime(int time)
  157. {
  158. return CalculateDuration(GetPoint(POINT_CASTING_SPEED), time);
  159. }
  161. void CHARACTER::SkillLevelPacket()
  162. {
  163. if (!GetDesc())
  164. return;
  166. TPacketGCSkillLevel pack;
  168. pack.bHeader = HEADER_GC_SKILL_LEVEL;
  169. thecore_memcpy(&pack.skills, m_pSkillLevels, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
  170. GetDesc()->Packet(&pack, sizeof(TPacketGCSkillLevel));
  171. }
  173. void CHARACTER::SetSkillLevel(DWORD dwVnum, BYTE bLev)
  174. {
  175. if (NULL == m_pSkillLevels)
  176. return;
  178. if (dwVnum >= SKILL_MAX_NUM)
  179. {
  180. sys_err("vnum overflow (vnum %u)", dwVnum);
  181. return;
  182. }
  184. m_pSkillLevels[dwVnum].bLevel = MIN(40, bLev);
  186. if (bLev >= 40)
  187. m_pSkillLevels[dwVnum].bMasterType = SKILL_PERFECT_MASTER;
  188. else if (bLev >= 30)
  189. m_pSkillLevels[dwVnum].bMasterType = SKILL_GRAND_MASTER;
  190. else if (bLev >= 20)
  191. m_pSkillLevels[dwVnum].bMasterType = SKILL_MASTER;
  192. else
  193. m_pSkillLevels[dwVnum].bMasterType = SKILL_NORMAL;
  194. }
  196. bool CHARACTER::IsLearnableSkill(DWORD dwSkillVnum) const
  197. {
  198. const CSkillProto * pkSkill = CSkillManager::instance().Get(dwSkillVnum);
  200. if (!pkSkill)
  201. return false;
  203. if (GetSkillLevel(dwSkillVnum) >= SKILL_MAX_LEVEL)
  204. return false;
  206. if (pkSkill->dwType == 0)
  207. {
  208. if (GetSkillLevel(dwSkillVnum) >= pkSkill->bMaxLevel)
  209. return false;
  211. return true;
  212. }
  214. if (pkSkill->dwType == 5)
  215. {
  216. if (dwSkillVnum == SKILL_HORSE_WILDATTACK_RANGE && GetJob() != JOB_ASSASSIN)
  217. return false;
  219. return true;
  220. }
  222. if (GetSkillGroup() == 0)
  223. return false;
  225. if (pkSkill->dwType - 1 == GetJob())
  226. return true;
  227. #ifdef ENABLE_WOLFMAN_CHARACTER
  228. // ¼öÀÎÁ· ½ºÅ³
  229. if (7 == pkSkill->dwType && JOB_WOLFMAN == GetJob())
  230. return true;
  231. #endif
  232. if (6 == pkSkill->dwType)
  233. {
  234. if (SKILL_7_A_ANTI_TANHWAN <= dwSkillVnum && dwSkillVnum <= SKILL_7_D_ANTI_YONGBI)
  235. {
  236. for (int i=0 ; i < 4 ; i++)
  237. {
  238. if (unsigned(SKILL_7_A_ANTI_TANHWAN + i) != dwSkillVnum)
  239. {
  240. if (0 != GetSkillLevel(SKILL_7_A_ANTI_TANHWAN + i))
  241. {
  242. return false;
  243. }
  244. }
  245. }
  247. return true;
  248. }
  250. if (SKILL_8_A_ANTI_GIGONGCHAM <= dwSkillVnum && dwSkillVnum <= SKILL_8_D_ANTI_BYEURAK)
  251. {
  252. for (int i=0 ; i < 4 ; i++)
  253. {
  254. if (unsigned(SKILL_8_A_ANTI_GIGONGCHAM + i) != dwSkillVnum)
  255. {
  256. if (0 != GetSkillLevel(SKILL_8_A_ANTI_GIGONGCHAM + i))
  257. return false;
  258. }
  259. }
  261. return true;
  262. }
  263. }
  265. return false;
  266. }
  268. // ADD_GRANDMASTER_SKILL
  269. bool CHARACTER::LearnGrandMasterSkill(DWORD dwSkillVnum)
  270. {
  271. CSkillProto * pkSk = CSkillManager::instance().Get(dwSkillVnum);
  273. if (!pkSk)
  274. return false;
  276. if (!IsLearnableSkill(dwSkillVnum))
  277. {
  278. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÇÒ ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù."));
  279. return false;
  280. }
  282. sys_log(0, "learn grand master skill[%d] cur %d, next %d", dwSkillVnum, get_global_time(), GetSkillNextReadTime(dwSkillVnum));
  284. /*
  285. if (get_global_time() < GetSkillNextReadTime(dwSkillVnum))
  286. {
  287. if (!(test_server && quest::CQuestManager::instance().GetEventFlag("no_read_delay")))
  288. {
  289. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
  290. {
  291. // Á־ȼú¼­ »ç¿ëÁß¿¡´Â ½Ã°£ Á¦ÇÑ ¹«½Ã
  292. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
  293. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á־ȼú¼­¸¦ ÅëÇØ ÁÖÈ­ÀÔ¸¶¿¡¼­ ºüÁ®³ª¿Ô½À´Ï´Ù."));
  294. }
  295. else
  296. {
  297. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
  298. return false;
  299. }
  300. }
  301. }
  302. */
  304. // bTypeÀÌ 0À̸é óÀ½ºÎÅÍ Ã¥À¸·Î ¼ö·Ã °¡´É
  305. if (pkSk->dwType == 0)
  306. {
  307. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±×·£µå ¸¶½ºÅÍ ¼ö·ÃÀ» ÇÒ ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù."));
  308. return false;
  309. }
  311. if (GetSkillMasterType(dwSkillVnum) != SKILL_GRAND_MASTER)
  312. {
  313. if (GetSkillMasterType(dwSkillVnum) > SKILL_GRAND_MASTER)
  314. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÆÛÆåÆ® ¸¶½ºÅÍµÈ ½ºÅ³ÀÔ´Ï´Ù. ´õ ÀÌ»ó ¼ö·Ã ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  315. else
  316. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ½ºÅ³Àº ¾ÆÁ÷ ±×·£µå ¸¶½ºÅÍ ¼ö·ÃÀ» ÇÒ °æÁö¿¡ À̸£Áö ¾Ê¾Ò½À´Ï´Ù."));
  317. return false;
  318. }
  320. std::string strTrainSkill;
  321. {
  322. std::ostringstream os;
  323. os << "training_grandmaster_skill.skill" << dwSkillVnum;
  324. strTrainSkill = os.str();
  325. }
  327. // ¿©±â¼­ È®·üÀ» °è»êÇÕ´Ï´Ù.
  328. BYTE bLastLevel = GetSkillLevel(dwSkillVnum);
  330. int idx = MIN(9, GetSkillLevel(dwSkillVnum) - 30);
  332. sys_log(0, "LearnGrandMasterSkill %s table idx %d value %d", GetName(), idx, aiGrandMasterSkillBookCountForLevelUp[idx]);
  334. int iTotalReadCount = GetQuestFlag(strTrainSkill) + 1;
  335. SetQuestFlag(strTrainSkill, iTotalReadCount);
  337. int iMinReadCount = aiGrandMasterSkillBookMinCount[idx];
  338. int iMaxReadCount = aiGrandMasterSkillBookMaxCount[idx];
  340. int iBookCount = aiGrandMasterSkillBookCountForLevelUp[idx];
  342. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
  343. {
  344. if (iBookCount&1)
  345. iBookCount = iBookCount / 2 + 1;
  346. else
  347. iBookCount = iBookCount / 2;
  349. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
  350. }
  352. int n = number(1, iBookCount);
  353. sys_log(0, "Number(%d)", n);
  355. DWORD nextTime = get_global_time() + number(28800, 43200);
  357. sys_log(0, "GrandMaster SkillBookCount min %d cur %d max %d (next_time=%d)", iMinReadCount, iTotalReadCount, iMaxReadCount, nextTime);
  359. bool bSuccess = n == 2;
  361. if (iTotalReadCount < iMinReadCount)
  362. bSuccess = false;
  363. if (iTotalReadCount > iMaxReadCount)
  364. bSuccess = true;
  366. if (bSuccess)
  367. {
  368. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_QUEST);
  369. }
  371. SetSkillNextReadTime(dwSkillVnum, nextTime);
  373. if (bLastLevel == GetSkillLevel(dwSkillVnum))
  374. {
  375. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("Å©À¹, ±â°¡ ¿ª·ùÇÏ°í ÀÖ¾î! ÀÌ°Å ¼³¸¶ ÁÖÈ­ÀÔ¸¶Àΰ¡!? Á¨Àå!"));
  376. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÀÌ ½ÇÆĞ·Î ³¡³µ½À´Ï´Ù. ´Ù½Ã µµÀüÇØÁֽñ⠹ٶø´Ï´Ù."));
  377. LogManager::instance().CharLog(this, dwSkillVnum, "GM_READ_FAIL", "");
  378. return false;
  379. }
  381. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸ö¿¡¼­ ¹º°¡ ÈûÀÌ ÅÍÁ® ³ª¿À´Â ±âºĞÀ̾ß!"));
  382. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¶ß°Å¿î ¹«¾ùÀÌ °è¼Ó ¿ë¼ÚÀ½Ä¡°í ÀÖ¾î! ÀÌ°Ç, ÀÌ°ÍÀº!"));
  383. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ³ôÀº °æÁöÀÇ ¼ö·ÃÀ» ¼º°øÀûÀ¸·Î ³¡³»¼Ì½À´Ï´Ù."));
  384. LogManager::instance().CharLog(this, dwSkillVnum, "GM_READ_SUCCESS", "");
  385. return true;
  386. }
  387. // END_OF_ADD_GRANDMASTER_SKILL
  389. static bool FN_should_check_exp(LPCHARACTER ch)
  390. {
  391. // @warme005
  392. return ch->GetLevel() < gPlayerMaxLevel;
  393. }
  396. bool CHARACTER::LearnSkillByBook(DWORD dwSkillVnum, BYTE bProb)
  397. {
  398. const CSkillProto* pkSk = CSkillManager::instance().Get(dwSkillVnum);
  400. if (!pkSk)
  401. return false;
  403. if (!IsLearnableSkill(dwSkillVnum))
  404. {
  405. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÇÒ ¼ö ¾ø´Â ½ºÅ³ÀÔ´Ï´Ù."));
  406. return false;
  407. }
  409. DWORD need_exp = 0;
  411. if (FN_should_check_exp(this))
  412. {
  413. need_exp = 20000;
  415. if ( GetExp() < need_exp )
  416. {
  417. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°æÇèÄ¡°¡ ºÎÁ·ÇÏ¿© Ã¥À» ÀĞÀ» ¼ö ¾ø½À´Ï´Ù."));
  418. return false;
  419. }
  420. }
  422. // bTypeÀÌ 0À̸é óÀ½ºÎÅÍ Ã¥À¸·Î ¼ö·Ã °¡´É
  423. if (pkSk->dwType != 0)
  424. {
  425. if (GetSkillMasterType(dwSkillVnum) != SKILL_MASTER)
  426. {
  427. if (GetSkillMasterType(dwSkillVnum) > SKILL_MASTER)
  428. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ½ºÅ³Àº Ã¥À¸·Î ´õÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  429. else
  430. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ½ºÅ³Àº ¾ÆÁ÷ Ã¥À¸·Î ¼ö·ÃÇÒ °æÁö¿¡ À̸£Áö ¾Ê¾Ò½À´Ï´Ù."));
  431. return false;
  432. }
  433. }
  435. if (get_global_time() < GetSkillNextReadTime(dwSkillVnum))
  436. {
  437. if (!(test_server && quest::CQuestManager::instance().GetEventFlag("no_read_delay")))
  438. {
  439. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
  440. {
  441. // Á־ȼú¼­ »ç¿ëÁß¿¡´Â ½Ã°£ Á¦ÇÑ ¹«½Ã
  442. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
  443. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á־ȼú¼­¸¦ ÅëÇØ ÁÖÈ­ÀÔ¸¶¿¡¼­ ºüÁ®³ª¿Ô½À´Ï´Ù."));
  444. }
  445. else
  446. {
  447. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
  448. return false;
  449. }
  450. }
  451. }
  453. // ¿©±â¼­ È®·üÀ» °è»êÇÕ´Ï´Ù.
  454. BYTE bLastLevel = GetSkillLevel(dwSkillVnum);
  456. if (bProb != 0)
  457. {
  458. // SKILL_BOOK_BONUS
  459. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
  460. {
  461. bProb += bProb / 2;
  462. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
  463. }
  464. // END_OF_SKILL_BOOK_BONUS
  466. sys_log(0, "LearnSkillByBook Pct %u prob %d", dwSkillVnum, bProb);
  468. if (number(1, 100) <= bProb)
  469. {
  470. if (test_server)
  471. sys_log(0, "LearnSkillByBook %u SUCC", dwSkillVnum);
  473. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_BOOK);
  474. }
  475. else
  476. {
  477. if (test_server)
  478. sys_log(0, "LearnSkillByBook %u FAIL", dwSkillVnum);
  479. }
  480. }
  481. else
  482. {
  483. int idx = MIN(9, GetSkillLevel(dwSkillVnum) - 20);
  485. sys_log(0, "LearnSkillByBook %s table idx %d value %d", GetName(), idx, aiSkillBookCountForLevelUp[idx]);
  487. {
  488. int need_bookcount = GetSkillLevel(dwSkillVnum) - 20;
  490. PointChange(POINT_EXP, -need_exp);
  492. quest::CQuestManager& q = quest::CQuestManager::instance();
  493. quest::PC* pPC = q.GetPC(GetPlayerID());
  495. if (pPC)
  496. {
  497. char flag[128+1];
  498. memset(flag, 0, sizeof(flag));
  499. snprintf(flag, sizeof(flag), "traning_master_skill.%u.read_count", dwSkillVnum);
  501. int read_count = pPC->GetFlag(flag);
  502. int percent = 65;
  504. if (FindAffect(AFFECT_SKILL_BOOK_BONUS))
  505. {
  506. percent = 0;
  507. RemoveAffect(AFFECT_SKILL_BOOK_BONUS);
  508. }
  510. if (number(1, 100) > percent)
  511. {
  512. // Ã¥Àб⿡ ¼º°ø
  513. if (read_count >= need_bookcount)
  514. {
  515. SkillLevelUp(dwSkillVnum, SKILL_UP_BY_BOOK);
  516. pPC->SetFlag(flag, 0);
  518. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ã¥À¸·Î ´õ ³ôÀº °æÁöÀÇ ¼ö·ÃÀ» ¼º°øÀûÀ¸·Î ³¡³»¼Ì½À´Ï´Ù."));
  519. LogManager::instance().CharLog(this, dwSkillVnum, "READ_SUCCESS", "");
  520. return true;
  521. }
  522. else
  523. {
  524. pPC->SetFlag(flag, read_count + 1);
  526. switch (number(1, 3))
  527. {
  528. case 1:
  529. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¾î´ÀÁ¤µµ ÀÌ ±â¼ú¿¡ ´ëÇØ ÀÌÇØ°¡ µÇ¾úÁö¸¸ Á¶±İ ºÎÁ·Çѵí Çѵ¥.."));
  530. break;
  532. case 2:
  533. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("µåµğ¾î ³¡ÀÌ º¸ÀÌ´Â °Ç°¡... ÀÌ ±â¼úÀº ÀÌÇØÇϱⰡ ³Ê¹« Èûµé¾î.."));
  534. break;
  536. case 3:
  537. default:
  538. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¿­½ÉÈ÷ ÇÏ´Â ¹è¿òÀ» °¡Áö´Â °Í¸¸ÀÌ ±â¼úÀ» ¹è¿ï¼ö ÀÖ´Â À¯ÀÏÇÑ ±æÀÌ´Ù.."));
  539. break;
  540. }
  542. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d ±ÇÀ» ´õ Àоî¾ß ¼ö·ÃÀ» ¿Ï·á ÇÒ ¼ö ÀÖ½À´Ï´Ù."), need_bookcount - read_count);
  543. return true;
  544. }
  545. }
  546. }
  547. else
  548. {
  549. // »ç¿ëÀÚÀÇ Äù½ºÆ® Á¤º¸ ·Îµå ½ÇÆĞ
  550. }
  551. }
  552. }
  554. if (bLastLevel != GetSkillLevel(dwSkillVnum))
  555. {
  556. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸ö¿¡¼­ ¹º°¡ ÈûÀÌ ÅÍÁ® ³ª¿À´Â ±âºĞÀ̾ß!"));
  557. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¶ß°Å¿î ¹«¾ùÀÌ °è¼Ó ¿ë¼ÚÀ½Ä¡°í ÀÖ¾î! ÀÌ°Ç, ÀÌ°ÍÀº!"));
  558. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ã¥À¸·Î ´õ ³ôÀº °æÁöÀÇ ¼ö·ÃÀ» ¼º°øÀûÀ¸·Î ³¡³»¼Ì½À´Ï´Ù."));
  559. LogManager::instance().CharLog(this, dwSkillVnum, "READ_SUCCESS", "");
  560. }
  561. else
  562. {
  563. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("Å©À¹, ±â°¡ ¿ª·ùÇÏ°í ÀÖ¾î! ÀÌ°Å ¼³¸¶ ÁÖÈ­ÀÔ¸¶Àΰ¡!? Á¨Àå!"));
  564. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ö·ÃÀÌ ½ÇÆĞ·Î ³¡³µ½À´Ï´Ù. ´Ù½Ã µµÀüÇØÁֽñ⠹ٶø´Ï´Ù."));
  565. LogManager::instance().CharLog(this, dwSkillVnum, "READ_FAIL", "");
  566. }
  568. return true;
  569. }
  571. bool CHARACTER::SkillLevelDown(DWORD dwVnum)
  572. {
  573. if (NULL == m_pSkillLevels)
  574. return false;
  576. if (g_bSkillDisable)
  577. return false;
  579. if (IsPolymorphed())
  580. return false;
  582. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
  584. if (!pkSk)
  585. {
  586. sys_err("There is no such skill by number %u", dwVnum);
  587. return false;
  588. }
  590. if (!IsLearnableSkill(dwVnum))
  591. return false;
  593. if (GetSkillMasterType(pkSk->dwVnum) != SKILL_NORMAL)
  594. return false;
  596. if (!GetSkillGroup())
  597. return false;
  599. if (pkSk->dwVnum >= SKILL_MAX_NUM)
  600. return false;
  602. if (m_pSkillLevels[pkSk->dwVnum].bLevel == 0)
  603. return false;
  605. int idx = POINT_SKILL;
  606. switch (pkSk->dwType)
  607. {
  608. case 0:
  609. idx = POINT_SUB_SKILL;
  610. break;
  611. case 1:
  612. case 2:
  613. case 3:
  614. case 4:
  615. case 6:
  616. #ifdef ENABLE_WOLFMAN_CHARACTER
  617. case 7:
  618. #endif
  619. idx = POINT_SKILL;
  620. break;
  621. case 5:
  622. idx = POINT_HORSE_SKILL;
  623. break;
  624. default:
  625. sys_err("Wrong skill type %d skill vnum %d", pkSk->dwType, pkSk->dwVnum);
  626. return false;
  628. }
  630. PointChange(idx, +1);
  631. SetSkillLevel(pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bLevel - 1);
  633. 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);
  634. Save();
  636. ComputePoints();
  637. SkillLevelPacket();
  638. return true;
  639. }
  641. void CHARACTER::SkillLevelUp(DWORD dwVnum, BYTE bMethod)
  642. {
  643. if (NULL == m_pSkillLevels)
  644. return;
  646. if (g_bSkillDisable)
  647. return;
  649. if (IsPolymorphed())
  650. {
  651. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µĞ°© Áß¿¡´Â ´É·ÂÀ» ¿Ã¸± ¼ö ¾ø½À´Ï´Ù."));
  652. return;
  653. }
  655. if (SKILL_7_A_ANTI_TANHWAN <= dwVnum && dwVnum <= SKILL_8_D_ANTI_BYEURAK)
  656. {
  657. if (0 == GetSkillLevel(dwVnum))
  658. return;
  659. }
  661. const CSkillProto* pkSk = CSkillManager::instance().Get(dwVnum);
  663. if (!pkSk)
  664. {
  665. sys_err("There is no such skill by number (vnum %u)", dwVnum);
  666. return;
  667. }
  669. if (pkSk->dwVnum >= SKILL_MAX_NUM)
  670. {
  671. sys_err("Skill Vnum overflow (vnum %u)", dwVnum);
  672. return;
  673. }
  675. if (!IsLearnableSkill(dwVnum))
  676. return;
  678. // ±×·£µå ¸¶½ºÅÍ´Â Äù½ºÆ®·Î¸¸ ¼öÇà°¡´É
  679. if (pkSk->dwType != 0)
  680. {
  681. switch (GetSkillMasterType(pkSk->dwVnum))
  682. {
  683. case SKILL_GRAND_MASTER:
  684. if (bMethod != SKILL_UP_BY_QUEST)
  685. return;
  686. break;
  688. case SKILL_PERFECT_MASTER:
  689. return;
  690. }
  691. }
  693. if (bMethod == SKILL_UP_BY_POINT)
  694. {
  695. // ¸¶½ºÅÍ°¡ ¾Æ´Ñ »óÅ¿¡¼­¸¸ ¼ö·Ã°¡´É
  696. if (GetSkillMasterType(pkSk->dwVnum) != SKILL_NORMAL)
  697. return;
  699. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_DISABLE_BY_POINT_UP))
  700. return;
  701. }
  702. else if (bMethod == SKILL_UP_BY_BOOK)
  703. {
  704. if (pkSk->dwType != 0) // Á÷¾÷¿¡ ¼ÓÇÏÁö ¾Ê¾Ò°Å³ª Æ÷ÀÎÆ®·Î ¿Ã¸±¼ö ¾ø´Â ½ºÅ³Àº óÀ½ºÎÅÍ Ã¥À¸·Î ¹è¿ï ¼ö ÀÖ´Ù.
  705. if (GetSkillMasterType(pkSk->dwVnum) != SKILL_MASTER)
  706. return;
  707. }
  709. if (GetLevel() < pkSk->bLevelLimit)
  710. return;
  712. if (pkSk->preSkillVnum)
  713. if (GetSkillMasterType(pkSk->preSkillVnum) == SKILL_NORMAL &&
  714. GetSkillLevel(pkSk->preSkillVnum) < pkSk->preSkillLevel)
  715. return;
  717. if (!GetSkillGroup())
  718. return;
  720. if (bMethod == SKILL_UP_BY_POINT)
  721. {
  722. int idx;
  724. switch (pkSk->dwType)
  725. {
  726. case 0:
  727. idx = POINT_SUB_SKILL;
  728. break;
  730. case 1:
  731. case 2:
  732. case 3:
  733. case 4:
  734. case 6:
  735. #ifdef ENABLE_WOLFMAN_CHARACTER
  736. case 7:
  737. #endif
  738. idx = POINT_SKILL;
  739. break;
  741. case 5:
  742. idx = POINT_HORSE_SKILL;
  743. break;
  745. default:
  746. sys_err("Wrong skill type %d skill vnum %d", pkSk->dwType, pkSk->dwVnum);
  747. return;
  748. }
  750. if (GetPoint(idx) < 1)
  751. return;
  753. PointChange(idx, -1);
  754. }
  756. int SkillPointBefore = GetSkillLevel(pkSk->dwVnum);
  757. SetSkillLevel(pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bLevel + 1);
  759. if (pkSk->dwType != 0)
  760. {
  761. // °©Àڱ⠱׷¹ÀÌµå ¾÷ÇÏ´Â ÄÚµù
  762. switch (GetSkillMasterType(pkSk->dwVnum))
  763. {
  764. case SKILL_NORMAL:
  765. // ¹ø¼·Àº ½ºÅ³ ¾÷±×·¹À̵å 17~20 »çÀÌ ·£´ı ¸¶½ºÅÍ ¼ö·Ã
  766. if (GetSkillLevel(pkSk->dwVnum) >= 16)
  767. {
  768. #ifdef ENABLE_FORCE2MASTERSKILL
  769. SetSkillLevel(pkSk->dwVnum, 20);
  770. #else
  771. if (GetQuestFlag("reset_scroll.force_to_master_skill") > 0)
  772. {
  773. SetSkillLevel(pkSk->dwVnum, 20);
  774. SetQuestFlag("reset_scroll.force_to_master_skill", 0);
  775. }
  776. else
  777. {
  778. if (number(1, 21 - MIN(20, GetSkillLevel(pkSk->dwVnum))) == 1)
  779. SetSkillLevel(pkSk->dwVnum, 20);
  780. }
  781. #endif
  782. }
  783. break;
  785. case SKILL_MASTER:
  786. if (GetSkillLevel(pkSk->dwVnum) >= 30)
  787. {
  788. if (number(1, 31 - MIN(30, GetSkillLevel(pkSk->dwVnum))) == 1)
  789. SetSkillLevel(pkSk->dwVnum, 30);
  790. }
  791. break;
  793. case SKILL_GRAND_MASTER:
  794. if (GetSkillLevel(pkSk->dwVnum) >= 40)
  795. {
  796. SetSkillLevel(pkSk->dwVnum, 40);
  797. }
  798. break;
  799. }
  800. }
  802. char szSkillUp[1024];
  804. snprintf(szSkillUp, sizeof(szSkillUp), "SkillUp: %s %u %d %d[Before:%d] type %u",
  805. GetName(), pkSk->dwVnum, m_pSkillLevels[pkSk->dwVnum].bMasterType, m_pSkillLevels[pkSk->dwVnum].bLevel, SkillPointBefore, pkSk->dwType);
  807. sys_log(0, "%s", szSkillUp);
  809. LogManager::instance().CharLog(this, pkSk->dwVnum, "SKILLUP", szSkillUp);
  810. Save();
  812. ComputePoints();
  813. SkillLevelPacket();
  814. }
  816. void CHARACTER::ComputeSkillPoints()
  817. {
  818. if (g_bSkillDisable)
  819. return;
  820. }
  822. void CHARACTER::ResetSkill()
  823. {
  824. if (NULL == m_pSkillLevels)
  825. return;
  827. // º¸Á¶ ½ºÅ³Àº ¸®¼Â½ÃÅ°Áö ¾Ê´Â´Ù
  828. std::vector<std::pair<DWORD, TPlayerSkill> > vec;
  829. size_t count = sizeof(s_adwSubSkillVnums) / sizeof(s_adwSubSkillVnums[0]);
  831. for (size_t i = 0; i < count; ++i)
  832. {
  833. if (s_adwSubSkillVnums[i] >= SKILL_MAX_NUM)
  834. continue;
  836. vec.push_back(std::make_pair(s_adwSubSkillVnums[i], m_pSkillLevels[s_adwSubSkillVnums[i]]));
  837. }
  839. memset(m_pSkillLevels, 0, sizeof(TPlayerSkill) * SKILL_MAX_NUM);
  841. std::vector<std::pair<DWORD, TPlayerSkill> >::const_iterator iter = vec.begin();
  843. while (iter != vec.end())
  844. {
  845. const std::pair<DWORD, TPlayerSkill>& pair = *(iter++);
  846. m_pSkillLevels[pair.first] = pair.second;
  847. }
  849. ComputePoints();
  850. SkillLevelPacket();
  851. }
  853. void CHARACTER::ComputePassiveSkill(DWORD dwVnum)
  854. {
  855. if (g_bSkillDisable)
  856. return;
  858. if (GetSkillLevel(dwVnum) == 0)
  859. return;
  861. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
  862. pkSk->SetPointVar("k", GetSkillLevel(dwVnum));
  863. int iAmount = (int) pkSk->kPointPoly.Eval();
  865. sys_log(2, "%s passive #%d on %d amount %d", GetName(), dwVnum, pkSk->bPointOn, iAmount);
  866. PointChange(pkSk->bPointOn, iAmount);
  867. }
  869. struct FFindNearVictim
  870. {
  871. FFindNearVictim(LPCHARACTER center, LPCHARACTER attacker, const CHARACTER_SET& excepts_set = empty_set_)
  872. : m_pkChrCenter(center),
  873. m_pkChrNextTarget(NULL),
  874. m_pkChrAttacker(attacker),
  875. m_count(0),
  876. m_excepts_set(excepts_set)
  877. {
  878. }
  880. void operator ()(LPENTITY ent)
  881. {
  882. if (!ent->IsType(ENTITY_CHARACTER))
  883. return;
  885. LPCHARACTER pkChr = (LPCHARACTER) ent;
  887. if (!m_excepts_set.empty()) {
  888. if (m_excepts_set.find(pkChr) != m_excepts_set.end())
  889. return;
  890. }
  892. if (m_pkChrCenter == pkChr)
  893. return;
  895. if (!battle_is_attackable(m_pkChrAttacker, pkChr))
  896. {
  897. return;
  898. }
  900. if (abs(m_pkChrCenter->GetX() - pkChr->GetX()) > 1000 || abs(m_pkChrCenter->GetY() - pkChr->GetY()) > 1000)
  901. return;
  903. float fDist = DISTANCE_APPROX(m_pkChrCenter->GetX() - pkChr->GetX(), m_pkChrCenter->GetY() - pkChr->GetY());
  905. if (fDist < 1000)
  906. {
  907. ++m_count;
  909. if ((m_count == 1) || number(1, m_count) == 1)
  910. m_pkChrNextTarget = pkChr;
  911. }
  912. }
  914. LPCHARACTER GetVictim()
  915. {
  916. return m_pkChrNextTarget;
  917. }
  919. LPCHARACTER m_pkChrCenter;
  920. LPCHARACTER m_pkChrNextTarget;
  921. LPCHARACTER m_pkChrAttacker;
  922. int m_count;
  923. const CHARACTER_SET & m_excepts_set;
  924. private:
  925. static CHARACTER_SET empty_set_;
  926. };
  928. CHARACTER_SET FFindNearVictim::empty_set_;
  930. EVENTINFO(chain_lightning_event_info)
  931. {
  932. DWORD dwVictim;
  933. DWORD dwChr;
  935. chain_lightning_event_info()
  936. : dwVictim(0)
  937. , dwChr(0)
  938. {
  939. }
  940. };
  942. EVENTFUNC(ChainLightningEvent)
  943. {
  944. chain_lightning_event_info * info = dynamic_cast<chain_lightning_event_info *>( event->info );
  946. LPCHARACTER pkChrVictim = CHARACTER_MANAGER::instance().Find(info->dwVictim);
  947. LPCHARACTER pkChr = CHARACTER_MANAGER::instance().Find(info->dwChr);
  948. LPCHARACTER pkTarget = NULL;
  950. if (!pkChr || !pkChrVictim)
  951. {
  952. sys_log(1, "use chainlighting, but no character");
  953. return 0;
  954. }
  956. sys_log(1, "chainlighting event %s", pkChr->GetName());
  958. if (pkChrVictim->GetParty()) // ÆÄƼ ¸ÕÀú
  959. {
  960. pkTarget = pkChrVictim->GetParty()->GetNextOwnership(NULL, pkChrVictim->GetX(), pkChrVictim->GetY());
  961. if (pkTarget == pkChrVictim || !number(0, 2) || pkChr->GetChainLightingExcept().find(pkTarget) != pkChr->GetChainLightingExcept().end())
  962. pkTarget = NULL;
  963. }
  965. if (!pkTarget)
  966. {
  967. // 1. Find Next victim
  968. FFindNearVictim f(pkChrVictim, pkChr, pkChr->GetChainLightingExcept());
  970. if (pkChrVictim->GetSectree())
  971. {
  972. pkChrVictim->GetSectree()->ForEachAround(f);
  973. // 2. If exist, compute it again
  974. pkTarget = f.GetVictim();
  975. }
  976. }
  978. if (pkTarget)
  979. {
  980. pkChrVictim->CreateFly(FLY_CHAIN_LIGHTNING, pkTarget);
  981. pkChr->ComputeSkill(SKILL_CHAIN, pkTarget);
  982. pkChr->AddChainLightningExcept(pkTarget);
  983. }
  984. else
  985. {
  986. sys_log(1, "%s use chainlighting, but find victim failed near %s", pkChr->GetName(), pkChrVictim->GetName());
  987. }
  989. return 0;
  990. }
  992. void SetPolyVarForAttack(LPCHARACTER ch, CSkillProto * pkSk, LPITEM pkWeapon)
  993. {
  994. if (ch->IsPC())
  995. {
  996. if (pkWeapon && pkWeapon->GetType() == ITEM_WEAPON)
  997. {
  998. int iWep = number(pkWeapon->GetValue(3), pkWeapon->GetValue(4));
  999. iWep += pkWeapon->GetValue(5);
  1001. int iMtk = number(pkWeapon->GetValue(1), pkWeapon->GetValue(2));
  1002. iMtk += pkWeapon->GetValue(5);
  1004. pkSk->SetPointVar("wep", iWep);
  1005. pkSk->SetPointVar("mtk", iMtk);
  1006. pkSk->SetPointVar("mwep", iMtk);
  1007. }
  1008. else
  1009. {
  1010. pkSk->SetPointVar("wep", 0);
  1011. pkSk->SetPointVar("mtk", 0);
  1012. pkSk->SetPointVar("mwep", 0);
  1013. }
  1014. }
  1015. else
  1016. {
  1017. int iWep = number(ch->GetMobDamageMin(), ch->GetMobDamageMax());
  1018. pkSk->SetPointVar("wep", iWep);
  1019. pkSk->SetPointVar("mwep", iWep);
  1020. pkSk->SetPointVar("mtk", iWep);
  1021. }
  1022. }
  1024. struct FuncSplashDamage
  1025. {
  1026. FuncSplashDamage(int x, int y, CSkillProto * pkSk, LPCHARACTER pkChr, int iAmount, int iAG, int iMaxHit, LPITEM pkWeapon, bool bDisableCooltime, TSkillUseInfo* pInfo, BYTE bUseSkillPower)
  1027. :
  1028. 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)
  1029. {
  1030. }
  1032. void operator () (LPENTITY ent)
  1033. {
  1034. if (!ent->IsType(ENTITY_CHARACTER))
  1035. {
  1036. //if (m_pkSk->dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN target not character %s", m_pkChr->GetName());
  1037. return;
  1038. }
  1040. LPCHARACTER pkChrVictim = (LPCHARACTER) ent;
  1042. if (DISTANCE_APPROX(m_x - pkChrVictim->GetX(), m_y - pkChrVictim->GetY()) > m_pkSk->iSplashRange)
  1043. {
  1044. if(test_server)
  1045. sys_log(0, "XXX target too far %s", m_pkChr->GetName());
  1046. return;
  1047. }
  1049. if (!battle_is_attackable(m_pkChr, pkChrVictim))
  1050. {
  1051. if(test_server)
  1052. sys_log(0, "XXX target not attackable %s", m_pkChr->GetName());
  1053. return;
  1054. }
  1056. if (m_pkChr->IsPC())
  1057. // ±æµå ½ºÅ³Àº ÄğŸÀÓ Ã³¸®¸¦ ÇÏÁö ¾Ê´Â´Ù.
  1058. if (!(m_pkSk->dwVnum >= GUILD_SKILL_START && m_pkSk->dwVnum <= GUILD_SKILL_END))
  1059. if (!m_bDisableCooltime && m_pInfo && !m_pInfo->HitOnce(m_pkSk->dwVnum) && m_pkSk->dwVnum != SKILL_MUYEONG)
  1060. {
  1061. if(test_server)
  1062. sys_log(0, "check guild skill %s", m_pkChr->GetName());
  1063. return;
  1064. }
  1066. ++m_iCount;
  1068. int iDam;
  1070. ////////////////////////////////////////////////////////////////////////////////
  1071. //float k = 1.0f * m_pkChr->GetSkillPower(m_pkSk->dwVnum) * m_pkSk->bMaxLevel / 100;
  1072. //m_pkSk->kPointPoly2.SetVar("k", 1.0 * m_bUseSkillPower * m_pkSk->bMaxLevel / 100);
  1073. m_pkSk->SetPointVar("k", 1.0 * m_bUseSkillPower * m_pkSk->bMaxLevel / 100);
  1074. m_pkSk->SetPointVar("lv", m_pkChr->GetLevel());
  1075. m_pkSk->SetPointVar("iq", m_pkChr->GetPoint(POINT_IQ));
  1076. m_pkSk->SetPointVar("str", m_pkChr->GetPoint(POINT_ST));
  1077. m_pkSk->SetPointVar("dex", m_pkChr->GetPoint(POINT_DX));
  1078. m_pkSk->SetPointVar("con", m_pkChr->GetPoint(POINT_HT));
  1079. m_pkSk->SetPointVar("def", m_pkChr->GetPoint(POINT_DEF_GRADE));
  1080. m_pkSk->SetPointVar("odef", m_pkChr->GetPoint(POINT_DEF_GRADE) - m_pkChr->GetPoint(POINT_DEF_GRADE_BONUS));
  1081. m_pkSk->SetPointVar("horse_level", m_pkChr->GetHorseLevel());
  1083. //int iPenetratePct = (int)(1 + k*4);
  1084. bool bIgnoreDefense = false;
  1086. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_PENETRATE))
  1087. {
  1088. int iPenetratePct = (int) m_pkSk->kPointPoly2.Eval();
  1090. if (number(1, 100) <= iPenetratePct)
  1091. bIgnoreDefense = true;
  1092. }
  1094. bool bIgnoreTargetRating = false;
  1096. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_IGNORE_TARGET_RATING))
  1097. {
  1098. int iPct = (int) m_pkSk->kPointPoly2.Eval();
  1100. if (number(1, 100) <= iPct)
  1101. bIgnoreTargetRating = true;
  1102. }
  1104. m_pkSk->SetPointVar("ar", CalcAttackRating(m_pkChr, pkChrVictim, bIgnoreTargetRating));
  1106. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_USE_MELEE_DAMAGE))
  1107. m_pkSk->SetPointVar("atk", CalcMeleeDamage(m_pkChr, pkChrVictim, true, bIgnoreTargetRating));
  1108. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_USE_ARROW_DAMAGE))
  1109. {
  1110. LPITEM pkBow, pkArrow;
  1112. if (1 == m_pkChr->GetArrowAndBow(&pkBow, &pkArrow, 1))
  1113. m_pkSk->SetPointVar("atk", CalcArrowDamage(m_pkChr, pkChrVictim, pkBow, pkArrow, true));
  1114. else
  1115. m_pkSk->SetPointVar("atk", 0);
  1116. }
  1118. if (m_pkSk->bPointOn == POINT_MOV_SPEED)
  1119. m_pkSk->kPointPoly.SetVar("maxv", pkChrVictim->GetLimitPoint(POINT_MOV_SPEED));
  1121. m_pkSk->SetPointVar("maxhp", pkChrVictim->GetMaxHP());
  1122. m_pkSk->SetPointVar("maxsp", pkChrVictim->GetMaxSP());
  1124. m_pkSk->SetPointVar("chain", m_pkChr->GetChainLightningIndex());
  1125. m_pkChr->IncChainLightningIndex();
  1127. bool bUnderEunhyung = m_pkChr->GetAffectedEunhyung() > 0; // ÀÌ°Ç ¿Ö ¿©±â¼­ ÇÏÁö??
  1129. m_pkSk->SetPointVar("ek", m_pkChr->GetAffectedEunhyung()*1./100);
  1130. //m_pkChr->ClearAffectedEunhyung();
  1131. SetPolyVarForAttack(m_pkChr, m_pkSk, m_pkWeapon);
  1133. int iAmount = 0;
  1135. if (m_pkChr->GetUsedSkillMasterType(m_pkSk->dwVnum) >= SKILL_GRAND_MASTER)
  1136. {
  1137. iAmount = (int) m_pkSk->kMasterBonusPoly.Eval();
  1138. }
  1139. else
  1140. {
  1141. iAmount = (int) m_pkSk->kPointPoly.Eval();
  1142. }
  1144. if (test_server && iAmount == 0 && m_pkSk->bPointOn != POINT_NONE)
  1145. {
  1146. m_pkChr->ChatPacket(CHAT_TYPE_INFO, "È¿°ú°¡ ¾ø½À´Ï´Ù. ½ºÅ³ °ø½ÄÀ» È®ÀÎÇϼ¼¿ä");
  1147. }
  1148. ////////////////////////////////////////////////////////////////////////////////
  1149. iAmount = -iAmount;
  1151. if (m_pkSk->dwVnum == SKILL_AMSEOP)
  1152. {
  1153. float fDelta = GetDegreeDelta(m_pkChr->GetRotation(), pkChrVictim->GetRotation());
  1154. float adjust;
  1156. if (fDelta < 35.0f)
  1157. {
  1158. adjust = 1.5f;
  1160. if (bUnderEunhyung)
  1161. adjust += 0.5f;
  1163. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
  1164. {
  1165. adjust += 0.5f;
  1166. }
  1167. }
  1168. else
  1169. {
  1170. adjust = 1.0f;
  1172. if (bUnderEunhyung)
  1173. adjust += 0.5f;
  1175. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
  1176. adjust += 0.5f;
  1177. }
  1179. iAmount = (int) (iAmount * adjust);
  1180. }
  1181. else if (m_pkSk->dwVnum == SKILL_GUNGSIN)
  1182. {
  1183. float adjust = 1.0;
  1185. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
  1186. {
  1187. adjust = 1.35f;
  1188. }
  1190. iAmount = (int) (iAmount * adjust);
  1191. }
  1192. #ifdef ENABLE_WOLFMAN_CHARACTER
  1193. else if (m_pkSk->dwVnum == SKILL_GONGDAB)
  1194. {
  1195. float adjust = 1.0;
  1197. if (m_pkChr->GetWear(WEAR_WEAPON) && m_pkChr->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_CLAW)
  1198. {
  1199. adjust = 1.35f;
  1200. }
  1202. iAmount = (int)(iAmount * adjust);
  1203. }
  1204. #endif
  1205. ////////////////////////////////////////////////////////////////////////////////
  1206. //sys_log(0, "name: %s skill: %s amount %d to %s", m_pkChr->GetName(), m_pkSk->szName, iAmount, pkChrVictim->GetName());
  1208. iDam = CalcBattleDamage(iAmount, m_pkChr->GetLevel(), pkChrVictim->GetLevel());
  1210. if (m_pkChr->IsPC() && m_pkChr->m_SkillUseInfo[m_pkSk->dwVnum].GetMainTargetVID() != (DWORD) pkChrVictim->GetVID())
  1211. {
  1212. // µ¥¹ÌÁö °¨¼Ò
  1213. iDam = (int) (iDam * m_pkSk->kSplashAroundDamageAdjustPoly.Eval());
  1214. }
  1216. // TODO ½ºÅ³¿¡ µû¸¥ µ¥¹ÌÁö ŸÀÔ ±â·ÏÇؾßÇÑ´Ù.
  1217. EDamageType dt = DAMAGE_TYPE_NONE;
  1219. switch (m_pkSk->bSkillAttrType)
  1220. {
  1221. case SKILL_ATTR_TYPE_NORMAL:
  1222. break;
  1224. case SKILL_ATTR_TYPE_MELEE:
  1225. {
  1226. dt = DAMAGE_TYPE_MELEE;
  1228. LPITEM pkWeapon = m_pkChr->GetWear(WEAR_WEAPON);
  1230. if (pkWeapon)
  1231. switch (pkWeapon->GetSubType())
  1232. {
  1233. case WEAPON_SWORD:
  1234. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_SWORD)) / 100;
  1235. break;
  1237. case WEAPON_TWO_HANDED:
  1238. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_TWOHAND)) / 100;
  1239. // ¾ç¼Õ°Ë Æä³ÎƼ 10%
  1240. //iDam = iDam * 95 / 100;
  1242. break;
  1244. case WEAPON_DAGGER:
  1245. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_DAGGER)) / 100;
  1246. break;
  1248. case WEAPON_BELL:
  1249. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_BELL)) / 100;
  1250. break;
  1252. case WEAPON_FAN:
  1253. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_FAN)) / 100;
  1254. break;
  1255. #ifdef ENABLE_WOLFMAN_CHARACTER
  1256. case WEAPON_CLAW:
  1257. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_CLAW)) / 100;
  1258. break;
  1259. #endif
  1260. }
  1262. if (!bIgnoreDefense)
  1263. iDam -= pkChrVictim->GetPoint(POINT_DEF_GRADE);
  1264. }
  1265. break;
  1267. case SKILL_ATTR_TYPE_RANGE:
  1268. dt = DAMAGE_TYPE_RANGE;
  1269. // À¸¾Æ¾Æ¾Æ¾Ç
  1270. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
  1271. //iDam -= pkChrVictim->GetPoint(POINT_DEF_GRADE);
  1272. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_BOW)) / 100;
  1273. break;
  1275. case SKILL_ATTR_TYPE_MAGIC:
  1276. dt = DAMAGE_TYPE_MAGIC;
  1277. iDam = CalcAttBonus(m_pkChr, pkChrVictim, iDam);
  1278. // À¸¾Æ¾Æ¾Æ¾Ç
  1279. // ¿¹Àü¿¡ Àû¿ë¾ÈÇß´ø ¹ö±×°¡ À־ ¹æ¾î·Â °è»êÀ» ´Ù½ÃÇϸé À¯Àú°¡ ³­¸®³²
  1280. //iDam -= pkChrVictim->GetPoint(POINT_MAGIC_DEF_GRADE);
  1281. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_MAGIC)) / 100;
  1282. break;
  1284. default:
  1285. sys_err("Unknown skill attr type %u vnum %u", m_pkSk->bSkillAttrType, m_pkSk->dwVnum);
  1286. break;
  1287. }
  1289. //
  1290. // 20091109 µ¶ÀÏ ½ºÅ³ ¼Ó¼º ¿äû ÀÛ¾÷
  1291. // ±âÁ¸ ½ºÅ³ Å×ÀÌºí¿¡ SKILL_FLAG_WIND, SKILL_FLAG_ELEC, SKILL_FLAG_FIRE¸¦ °¡Áø ½ºÅ³ÀÌ
  1292. // ÀüÇô ¾ø¾úÀ¸¹Ç·Î ¸ó½ºÅÍÀÇ RESIST_WIND, RESIST_ELEC, RESIST_FIREµµ »ç¿ëµÇÁö ¾Ê°í ÀÖ¾ú´Ù.
  1293. //
  1294. // PvP¿Í PvE¹ë·±½º ºĞ¸®¸¦ À§ÇØ ÀǵµÀûÀ¸·Î NPC¸¸ Àû¿ëÇϵµ·Ï ÇßÀ¸¸ç ±âÁ¸ ¹ë·±½º¿Í Â÷ÀÌÁ¡À»
  1295. // ´À³¢Áö ¸øÇϱâ À§ÇØ mob_protoÀÇ RESIST_MAGICÀ» RESIST_WIND, RESIST_ELEC, RESIST_FIRE·Î
  1296. // º¹»çÇÏ¿´´Ù.
  1297. //
  1298. if (pkChrVictim->IsNPC())
  1299. {
  1300. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_WIND))
  1301. {
  1302. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_WIND)) / 100;
  1303. }
  1305. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_ELEC))
  1306. {
  1307. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_ELEC)) / 100;
  1308. }
  1310. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_FIRE))
  1311. {
  1312. iDam = iDam * (100 - pkChrVictim->GetPoint(POINT_RESIST_FIRE)) / 100;
  1313. }
  1314. }
  1316. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_COMPUTE_MAGIC_DAMAGE))
  1317. dt = DAMAGE_TYPE_MAGIC;
  1319. if (pkChrVictim->CanBeginFight())
  1320. pkChrVictim->BeginFight(m_pkChr);
  1322. if (m_pkSk->dwVnum == SKILL_CHAIN)
  1323. sys_log(0, "%s CHAIN INDEX %d DAM %d DT %d", m_pkChr->GetName(), m_pkChr->GetChainLightningIndex() - 1, iDam, dt);
  1325. {
  1326. BYTE AntiSkillID = 0;
  1328. switch (m_pkSk->dwVnum)
  1329. {
  1330. case SKILL_TANHWAN: AntiSkillID = SKILL_7_A_ANTI_TANHWAN; break;
  1331. case SKILL_AMSEOP: AntiSkillID = SKILL_7_B_ANTI_AMSEOP; break;
  1332. case SKILL_SWAERYUNG: AntiSkillID = SKILL_7_C_ANTI_SWAERYUNG; break;
  1333. case SKILL_YONGBI: AntiSkillID = SKILL_7_D_ANTI_YONGBI; break;
  1334. case SKILL_GIGONGCHAM: AntiSkillID = SKILL_8_A_ANTI_GIGONGCHAM; break;
  1335. case SKILL_YEONSA: AntiSkillID = SKILL_8_B_ANTI_YEONSA; break;
  1336. case SKILL_MAHWAN: AntiSkillID = SKILL_8_C_ANTI_MAHWAN; break;
  1337. case SKILL_BYEURAK: AntiSkillID = SKILL_8_D_ANTI_BYEURAK; break;
  1338. }
  1340. if (0 != AntiSkillID)
  1341. {
  1342. BYTE AntiSkillLevel = pkChrVictim->GetSkillLevel(AntiSkillID);
  1344. if (0 != AntiSkillLevel)
  1345. {
  1346. CSkillProto* pkSk = CSkillManager::instance().Get(AntiSkillID);
  1347. if (!pkSk)
  1348. {
  1349. sys_err ("There is no anti skill(%d) in skill proto", AntiSkillID);
  1350. }
  1351. else
  1352. {
  1353. pkSk->SetPointVar("k", 1.0f * pkChrVictim->GetSkillPower(AntiSkillID) * pkSk->bMaxLevel / 100);
  1355. double ResistAmount = pkSk->kPointPoly.Eval();
  1357. sys_log(0, "ANTI_SKILL: Resist(%lf) Orig(%d) Reduce(%d)", ResistAmount, iDam, int(iDam * (ResistAmount/100.0)));
  1359. iDam -= iDam * (ResistAmount/100.0);
  1360. }
  1361. }
  1362. }
  1363. }
  1365. if (!pkChrVictim->Damage(m_pkChr, iDam, dt) && !pkChrVictim->IsStun())
  1366. {
  1367. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_REMOVE_GOOD_AFFECT))
  1368. {
  1369. #ifdef ENABLE_NULLIFYAFFECT_LIMIT
  1370. int iLevel = m_pkChr->GetLevel();
  1371. int yLevel = pkChrVictim->GetLevel();
  1372. // const float k = 1.0 * m_pkChr->GetSkillPower(m_pkSk->dwVnum, bSkillLevel) * m_pkSk->bMaxLevel / 100;
  1373. int iDifLev = 9;
  1374. if ((iLevel-iDifLev <= yLevel) && (iLevel+iDifLev >= yLevel))
  1375. #endif
  1376. {
  1377. int iAmount2 = (int) m_pkSk->kPointPoly2.Eval();
  1378. int iDur2 = (int) m_pkSk->kDurationPoly2.Eval();
  1379. iDur2 += m_pkChr->GetPoint(POINT_PARTY_BUFFER_BONUS);
  1381. if (number(1, 100) <= iAmount2)
  1382. {
  1383. pkChrVictim->RemoveGoodAffect();
  1384. pkChrVictim->AddAffect(m_pkSk->dwVnum, POINT_NONE, 0, AFF_PABEOP, iDur2, 0, true);
  1385. }
  1386. }
  1387. }
  1388. #ifdef ENABLE_WOLFMAN_CHARACTER
  1389. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SLOW | SKILL_FLAG_STUN | SKILL_FLAG_FIRE_CONT | SKILL_FLAG_POISON | SKILL_FLAG_BLEEDING))
  1390. #else
  1391. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SLOW | SKILL_FLAG_STUN | SKILL_FLAG_FIRE_CONT | SKILL_FLAG_POISON))
  1392. #endif
  1393. {
  1394. int iPct = (int) m_pkSk->kPointPoly2.Eval();
  1395. int iDur = (int) m_pkSk->kDurationPoly2.Eval();
  1397. iDur += m_pkChr->GetPoint(POINT_PARTY_BUFFER_BONUS);
  1399. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_STUN))
  1400. {
  1401. SkillAttackAffect(pkChrVictim, iPct, IMMUNE_STUN, AFFECT_STUN, POINT_NONE, 0, AFF_STUN, iDur, m_pkSk->szName);
  1402. }
  1403. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SLOW))
  1404. {
  1405. SkillAttackAffect(pkChrVictim, iPct, IMMUNE_SLOW, AFFECT_SLOW, POINT_MOV_SPEED, -30, AFF_SLOW, iDur, m_pkSk->szName);
  1406. }
  1407. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_FIRE_CONT))
  1408. {
  1409. m_pkSk->SetDurationVar("k", 1.0 * m_bUseSkillPower * m_pkSk->bMaxLevel / 100);
  1410. m_pkSk->SetDurationVar("iq", m_pkChr->GetPoint(POINT_IQ));
  1412. iDur = (int)m_pkSk->kDurationPoly2.Eval();
  1413. int bonus = m_pkChr->GetPoint(POINT_PARTY_BUFFER_BONUS);
  1415. if (bonus != 0)
  1416. {
  1417. iDur += bonus / 2;
  1418. }
  1420. if (number(1, 100) <= iDur)
  1421. {
  1422. pkChrVictim->AttackedByFire(m_pkChr, iPct, 5);
  1423. }
  1424. }
  1425. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_POISON))
  1426. {
  1427. if (number(1, 100) <= iPct)
  1428. pkChrVictim->AttackedByPoison(m_pkChr);
  1429. }
  1430. #ifdef ENABLE_WOLFMAN_CHARACTER
  1431. else if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_BLEEDING))
  1432. {
  1433. if (number(1, 100) <= iPct)
  1434. pkChrVictim->AttackedByBleeding(m_pkChr);
  1435. }
  1436. #endif
  1437. }
  1439. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_CRUSH | SKILL_FLAG_CRUSH_LONG) &&
  1440. !IS_SET(pkChrVictim->GetAIFlag(), AIFLAG_NOMOVE))
  1441. {
  1442. float fCrushSlidingLength = 200;
  1444. if (m_pkChr->IsNPC())
  1445. fCrushSlidingLength = 400;
  1447. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_CRUSH_LONG))
  1448. fCrushSlidingLength *= 2;
  1450. float fx, fy;
  1451. float degree = GetDegreeFromPositionXY(m_pkChr->GetX(), m_pkChr->GetY(), pkChrVictim->GetX(), pkChrVictim->GetY());
  1453. if (m_pkSk->dwVnum == SKILL_HORSE_WILDATTACK)
  1454. {
  1455. degree -= m_pkChr->GetRotation();
  1456. degree = fmod(degree, 360.0f) - 180.0f;
  1458. if (degree > 0)
  1459. degree = m_pkChr->GetRotation() + 90.0f;
  1460. else
  1461. degree = m_pkChr->GetRotation() - 90.0f;
  1462. }
  1464. GetDeltaByDegree(degree, fCrushSlidingLength, &fx, &fy);
  1465. 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));
  1466. long tx = (long)(pkChrVictim->GetX()+fx);
  1467. long ty = (long)(pkChrVictim->GetY()+fy);
  1469. pkChrVictim->Sync(tx, ty);
  1470. pkChrVictim->Goto(tx, ty);
  1471. pkChrVictim->CalculateMoveDuration();
  1473. if (m_pkChr->IsPC() && m_pkChr->m_SkillUseInfo[m_pkSk->dwVnum].GetMainTargetVID() == (DWORD) pkChrVictim->GetVID())
  1474. {
  1475. SkillAttackAffect(pkChrVictim, 1000, IMMUNE_STUN, m_pkSk->dwVnum, POINT_NONE, 0, AFF_STUN, 4, m_pkSk->szName);
  1476. }
  1477. else
  1478. {
  1479. pkChrVictim->SyncPacket();
  1480. }
  1481. }
  1482. }
  1484. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_HP_ABSORB))
  1485. {
  1486. int iPct = (int) m_pkSk->kPointPoly2.Eval();
  1487. m_pkChr->PointChange(POINT_HP, iDam * iPct / 100);
  1488. }
  1490. if (IS_SET(m_pkSk->dwFlag, SKILL_FLAG_SP_ABSORB))
  1491. {
  1492. int iPct = (int) m_pkSk->kPointPoly2.Eval();
  1493. m_pkChr->PointChange(POINT_SP, iDam * iPct / 100);
  1494. }
  1496. if (m_pkSk->dwVnum == SKILL_CHAIN && m_pkChr->GetChainLightningIndex() < m_pkChr->GetChainLightningMaxCount())
  1497. {
  1498. chain_lightning_event_info* info = AllocEventInfo<chain_lightning_event_info>();
  1500. info->dwVictim = pkChrVictim->GetVID();
  1501. info->dwChr = m_pkChr->GetVID();
  1503. event_create(ChainLightningEvent, info, passes_per_sec / 5);
  1504. }
  1505. if(test_server)
  1506. sys_log(0, "FuncSplashDamage End :%s ", m_pkChr->GetName());
  1507. }
  1509. int m_x;
  1510. int m_y;
  1511. CSkillProto * m_pkSk;
  1512. LPCHARACTER m_pkChr;
  1513. int m_iAmount;
  1514. int m_iAG;
  1515. int m_iCount;
  1516. int m_iMaxHit;
  1517. LPITEM m_pkWeapon;
  1518. bool m_bDisableCooltime;
  1519. TSkillUseInfo* m_pInfo;
  1520. BYTE m_bUseSkillPower;
  1521. };
  1523. struct FuncSplashAffect
  1524. {
  1525. 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)
  1526. {
  1527. m_x = x;
  1528. m_y = y;
  1529. m_iDist = iDist;
  1530. m_dwVnum = dwVnum;
  1531. m_bPointOn = bPointOn;
  1532. m_iAmount = iAmount;
  1533. m_dwAffectFlag = dwAffectFlag;
  1534. m_iDuration = iDuration;
  1535. m_iSPCost = iSPCost;
  1536. m_bOverride = bOverride;
  1537. m_pkChrAttacker = ch;
  1538. m_iMaxHit = iMaxHit;
  1539. m_iCount = 0;
  1540. }
  1542. void operator () (LPENTITY ent)
  1543. {
  1544. if (m_iMaxHit && m_iMaxHit <= m_iCount)
  1545. return;
  1547. if (ent->IsType(ENTITY_CHARACTER))
  1548. {
  1549. LPCHARACTER pkChr = (LPCHARACTER) ent;
  1551. if (test_server)
  1552. sys_log(0, "FuncSplashAffect step 1 : name:%s vnum:%d iDur:%d", pkChr->GetName(), m_dwVnum, m_iDuration);
  1553. if (DISTANCE_APPROX(m_x - pkChr->GetX(), m_y - pkChr->GetY()) < m_iDist)
  1554. {
  1555. if (test_server)
  1556. sys_log(0, "FuncSplashAffect step 2 : name:%s vnum:%d iDur:%d", pkChr->GetName(), m_dwVnum, m_iDuration);
  1557. if (m_dwVnum == SKILL_TUSOK)
  1558. if (pkChr->CanBeginFight())
  1559. pkChr->BeginFight(m_pkChrAttacker);
  1561. if (pkChr->IsPC() && m_dwVnum == SKILL_TUSOK)
  1562. pkChr->AddAffect(m_dwVnum, m_bPointOn, m_iAmount, m_dwAffectFlag, m_iDuration/3, m_iSPCost, m_bOverride);
  1563. else
  1564. pkChr->AddAffect(m_dwVnum, m_bPointOn, m_iAmount, m_dwAffectFlag, m_iDuration, m_iSPCost, m_bOverride);
  1566. m_iCount ++;
  1567. }
  1568. }
  1569. }
  1571. LPCHARACTER m_pkChrAttacker;
  1572. int m_x;
  1573. int m_y;
  1574. int m_iDist;
  1575. DWORD m_dwVnum;
  1576. BYTE m_bPointOn;
  1577. int m_iAmount;
  1578. DWORD m_dwAffectFlag;
  1579. int m_iDuration;
  1580. int m_iSPCost;
  1581. bool m_bOverride;
  1582. int m_iMaxHit;
  1583. int m_iCount;
  1584. };
  1586. EVENTINFO(skill_gwihwan_info)
  1587. {
  1588. DWORD pid;
  1589. BYTE bsklv;
  1591. skill_gwihwan_info()
  1592. : pid( 0 )
  1593. , bsklv( 0 )
  1594. {
  1595. }
  1596. };
  1598. EVENTFUNC(skill_gwihwan_event)
  1599. {
  1600. skill_gwihwan_info* info = dynamic_cast<skill_gwihwan_info*>( event->info );
  1602. if ( info == NULL )
  1603. {
  1604. sys_err( "skill_gwihwan_event> <Factor> Null pointer" );
  1605. return 0;
  1606. }
  1608. DWORD pid = info->pid;
  1609. BYTE sklv= info->bsklv;
  1610. LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(pid);
  1612. if (!ch)
  1613. return 0;
  1615. int percent = 20 * sklv - 1;
  1617. if (number(1, 100) <= percent)
  1618. {
  1619. PIXEL_POSITION pos;
  1621. // ¼º°ø
  1622. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(ch->GetMapIndex(), ch->GetEmpire(), pos))
  1623. {
  1624. sys_log(1, "Recall: %s %d %d -> %d %d", ch->GetName(), ch->GetX(), ch->GetY(), pos.x, pos.y);
  1625. ch->WarpSet(pos.x, pos.y);
  1626. }
  1627. else
  1628. {
  1629. sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", ch->GetName(), ch->GetX(), ch->GetY());
  1630. ch->WarpSet(EMPIRE_START_X(ch->GetEmpire()), EMPIRE_START_Y(ch->GetEmpire()));
  1631. }
  1632. }
  1633. else
  1634. {
  1635. //½ÇÆĞ
  1636. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±Íȯ¿¡ ½ÇÆĞÇÏ¿´½À´Ï´Ù."));
  1637. }
  1638. return 0;
  1639. }
  1641. int CHARACTER::ComputeSkillAtPosition(DWORD dwVnum, const PIXEL_POSITION& posTarget, BYTE bSkillLevel)
  1642. {
  1643. if (GetMountVnum())
  1644. return BATTLE_NONE;
  1646. if (IsPolymorphed())
  1647. return BATTLE_NONE;
  1649. if (g_bSkillDisable)
  1650. return BATTLE_NONE;
  1652. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
  1654. if (!pkSk)
  1655. return BATTLE_NONE;
  1657. if (test_server)
  1658. {
  1659. sys_log(0, "ComputeSkillAtPosition %s vnum %d x %d y %d level %d",
  1660. GetName(), dwVnum, posTarget.x, posTarget.y, bSkillLevel);
  1661. }
  1663. // ³ª¿¡°Ô ¾²´Â ½ºÅ³Àº ³» À§Ä¡¸¦ ¾´´Ù.
  1664. //if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
  1665. // posTarget = GetXYZ();
  1667. // ½ºÇ÷¡½¬°¡ ¾Æ´Ñ ½ºÅ³Àº ÁÖÀ§À̸é ÀÌ»óÇÏ´Ù
  1668. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  1669. return BATTLE_NONE;
  1671. if (0 == bSkillLevel)
  1672. {
  1673. if ((bSkillLevel = GetSkillLevel(pkSk->dwVnum)) == 0)
  1674. {
  1675. return BATTLE_NONE;
  1676. }
  1677. }
  1679. const float k = 1.0 * GetSkillPower(pkSk->dwVnum, bSkillLevel) * pkSk->bMaxLevel / 100;
  1681. pkSk->SetPointVar("k", k);
  1682. pkSk->kSplashAroundDamageAdjustPoly.SetVar("k", k);
  1684. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MELEE_DAMAGE))
  1685. {
  1686. pkSk->SetPointVar("atk", CalcMeleeDamage(this, this, true, false));
  1687. }
  1688. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MAGIC_DAMAGE))
  1689. {
  1690. pkSk->SetPointVar("atk", CalcMagicDamage(this, this));
  1691. }
  1692. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_ARROW_DAMAGE))
  1693. {
  1694. LPITEM pkBow, pkArrow;
  1695. if (1 == GetArrowAndBow(&pkBow, &pkArrow, 1))
  1696. {
  1697. pkSk->SetPointVar("atk", CalcArrowDamage(this, this, pkBow, pkArrow, true));
  1698. }
  1699. else
  1700. {
  1701. pkSk->SetPointVar("atk", 0);
  1702. }
  1703. }
  1705. if (pkSk->bPointOn == POINT_MOV_SPEED)
  1706. {
  1707. pkSk->SetPointVar("maxv", this->GetLimitPoint(POINT_MOV_SPEED));
  1708. }
  1710. pkSk->SetPointVar("lv", GetLevel());
  1711. pkSk->SetPointVar("iq", GetPoint(POINT_IQ));
  1712. pkSk->SetPointVar("str", GetPoint(POINT_ST));
  1713. pkSk->SetPointVar("dex", GetPoint(POINT_DX));
  1714. pkSk->SetPointVar("con", GetPoint(POINT_HT));
  1715. pkSk->SetPointVar("maxhp", this->GetMaxHP());
  1716. pkSk->SetPointVar("maxsp", this->GetMaxSP());
  1717. pkSk->SetPointVar("chain", 0);
  1718. pkSk->SetPointVar("ar", CalcAttackRating(this, this));
  1719. pkSk->SetPointVar("def", GetPoint(POINT_DEF_GRADE));
  1720. pkSk->SetPointVar("odef", GetPoint(POINT_DEF_GRADE) - GetPoint(POINT_DEF_GRADE_BONUS));
  1721. pkSk->SetPointVar("horse_level", GetHorseLevel());
  1723. if (pkSk->bSkillAttrType != SKILL_ATTR_TYPE_NORMAL)
  1724. OnMove(true);
  1726. LPITEM pkWeapon = GetWear(WEAR_WEAPON);
  1728. SetPolyVarForAttack(this, pkSk, pkWeapon);
  1730. pkSk->SetDurationVar("k", k/*bSkillLevel*/);
  1732. int iAmount = (int) pkSk->kPointPoly.Eval();
  1733. int iAmount2 = (int) pkSk->kPointPoly2.Eval();
  1735. // ADD_GRANDMASTER_SKILL
  1736. int iAmount3 = (int) pkSk->kPointPoly3.Eval();
  1738. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
  1739. {
  1740. /*
  1741. if (iAmount >= 0)
  1742. iAmount += (int) m_pkSk->kMasterBonusPoly.Eval();
  1743. else
  1744. iAmount -= (int) m_pkSk->kMasterBonusPoly.Eval();
  1745. */
  1746. iAmount = (int) pkSk->kMasterBonusPoly.Eval();
  1747. }
  1749. if (test_server && iAmount == 0 && pkSk->bPointOn != POINT_NONE)
  1750. {
  1751. ChatPacket(CHAT_TYPE_INFO, "È¿°ú°¡ ¾ø½À´Ï´Ù. ½ºÅ³ °ø½ÄÀ» È®ÀÎÇϼ¼¿ä");
  1752. }
  1754. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_REMOVE_BAD_AFFECT))
  1755. {
  1756. if (number(1, 100) <= iAmount2)
  1757. {
  1758. RemoveBadAffect();
  1759. }
  1760. }
  1761. // END_OF_ADD_GRANDMASTER_SKILL
  1763. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_ATTACK | SKILL_FLAG_USE_MELEE_DAMAGE | SKILL_FLAG_USE_MAGIC_DAMAGE))
  1764. {
  1765. //
  1766. // °ø°İ ½ºÅ³ÀÏ °æ¿ì
  1767. //
  1768. bool bAdded = false;
  1770. if (pkSk->bPointOn == POINT_HP && iAmount < 0)
  1771. {
  1772. int iAG = 0;
  1774. FuncSplashDamage f(posTarget.x, posTarget.y, pkSk, this, iAmount, iAG, pkSk->lMaxHit, pkWeapon, m_bDisableCooltime, IsPC()?&m_SkillUseInfo[dwVnum]:NULL, GetSkillPower(dwVnum, bSkillLevel));
  1776. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  1777. {
  1778. if (GetSectree())
  1779. GetSectree()->ForEachAround(f);
  1780. }
  1781. else
  1782. {
  1783. //if (dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN skill call FuncSplashDamage %s", GetName());
  1784. f(this);
  1785. }
  1786. }
  1787. else
  1788. {
  1789. //if (dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN skill no damage %d %s", iAmount, GetName());
  1790. int iDur = (int) pkSk->kDurationPoly.Eval();
  1792. if (IsPC())
  1793. if (!(dwVnum >= GUILD_SKILL_START && dwVnum <= GUILD_SKILL_END)) // ±æµå ½ºÅ³Àº ÄğŸÀÓ Ã³¸®¸¦ ÇÏÁö ¾Ê´Â´Ù.
  1794. if (!m_bDisableCooltime && !m_SkillUseInfo[dwVnum].HitOnce(dwVnum) && dwVnum != SKILL_MUYEONG)
  1795. {
  1796. //if (dwVnum == SKILL_CHAIN) sys_log(0, "CHAIN skill cannot hit %s", GetName());
  1797. return BATTLE_NONE;
  1798. }
  1801. if (iDur > 0)
  1802. {
  1803. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  1805. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  1806. AddAffect(pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true);
  1807. else
  1808. {
  1809. if (GetSectree())
  1810. {
  1811. FuncSplashAffect f(this, posTarget.x, posTarget.y, pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true, pkSk->lMaxHit);
  1812. GetSectree()->ForEachAround(f);
  1813. }
  1814. }
  1815. bAdded = true;
  1816. }
  1817. }
  1819. if (pkSk->bPointOn2 != POINT_NONE)
  1820. {
  1821. int iDur = (int) pkSk->kDurationPoly2.Eval();
  1823. sys_log(1, "try second %u %d %d", pkSk->dwVnum, pkSk->bPointOn2, iDur);
  1825. if (iDur > 0)
  1826. {
  1827. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  1829. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  1830. AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded);
  1831. else
  1832. {
  1833. if (GetSectree())
  1834. {
  1835. FuncSplashAffect f(this, posTarget.x, posTarget.y, pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded, pkSk->lMaxHit);
  1836. GetSectree()->ForEachAround(f);
  1837. }
  1838. }
  1839. bAdded = true;
  1840. }
  1841. else
  1842. {
  1843. PointChange(pkSk->bPointOn2, iAmount2);
  1844. }
  1845. }
  1847. // ADD_GRANDMASTER_SKILL
  1848. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER && pkSk->bPointOn3 != POINT_NONE)
  1849. {
  1850. int iDur = (int) pkSk->kDurationPoly3.Eval();
  1852. if (iDur > 0)
  1853. {
  1854. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  1856. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  1857. AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, 0 /*pkSk->dwAffectFlag3*/, iDur, 0, !bAdded);
  1858. else
  1859. {
  1860. if (GetSectree())
  1861. {
  1862. FuncSplashAffect f(this, posTarget.x, posTarget.y, pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn3, iAmount3, 0 /*pkSk->dwAffectFlag3*/, iDur, 0, !bAdded, pkSk->lMaxHit);
  1863. GetSectree()->ForEachAround(f);
  1864. }
  1865. }
  1866. }
  1867. else
  1868. {
  1869. PointChange(pkSk->bPointOn3, iAmount3);
  1870. }
  1871. }
  1872. // END_OF_ADD_GRANDMASTER_SKILL
  1874. return BATTLE_DAMAGE;
  1875. }
  1876. else
  1877. {
  1878. bool bAdded = false;
  1879. int iDur = (int) pkSk->kDurationPoly.Eval();
  1881. if (iDur > 0)
  1882. {
  1883. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  1884. // AffectFlag°¡ ¾ø°Å³ª, toggle ÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó¸é..
  1885. pkSk->kDurationSPCostPoly.SetVar("k", k/*bSkillLevel*/);
  1887. AddAffect(pkSk->dwVnum,
  1888. pkSk->bPointOn,
  1889. iAmount,
  1890. pkSk->dwAffectFlag,
  1891. iDur,
  1892. (long) pkSk->kDurationSPCostPoly.Eval(),
  1893. !bAdded);
  1895. bAdded = true;
  1896. }
  1897. else
  1898. {
  1899. PointChange(pkSk->bPointOn, iAmount);
  1900. }
  1902. if (pkSk->bPointOn2 != POINT_NONE)
  1903. {
  1904. int iDur = (int) pkSk->kDurationPoly2.Eval();
  1906. if (iDur > 0)
  1907. {
  1908. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  1909. AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded);
  1910. bAdded = true;
  1911. }
  1912. else
  1913. {
  1914. PointChange(pkSk->bPointOn2, iAmount2);
  1915. }
  1916. }
  1918. // ADD_GRANDMASTER_SKILL
  1919. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER && pkSk->bPointOn3 != POINT_NONE)
  1920. {
  1921. int iDur = (int) pkSk->kDurationPoly3.Eval();
  1923. if (iDur > 0)
  1924. {
  1925. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  1926. AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, 0 /*pkSk->dwAffectFlag3*/, iDur, 0, !bAdded);
  1927. }
  1928. else
  1929. {
  1930. PointChange(pkSk->bPointOn3, iAmount3);
  1931. }
  1932. }
  1933. // END_OF_ADD_GRANDMASTER_SKILL
  1935. return BATTLE_NONE;
  1936. }
  1937. }
  1939. #ifdef ENABLE_WOLFMAN_CHARACTER
  1940. struct FComputeSkillParty
  1941. {
  1942. FComputeSkillParty(DWORD dwVnum, LPCHARACTER pkAttacker, BYTE bSkillLevel = 0)
  1943. : m_dwVnum(dwVnum), m_pkAttacker(pkAttacker), m_bSkillLevel(bSkillLevel)
  1944. {
  1945. }
  1947. void operator () (LPCHARACTER ch)
  1948. {
  1949. m_pkAttacker->ComputeSkill(m_dwVnum, ch, m_bSkillLevel);
  1950. }
  1952. DWORD m_dwVnum;
  1953. LPCHARACTER m_pkAttacker;
  1954. BYTE m_bSkillLevel;
  1955. };
  1957. int CHARACTER::ComputeSkillParty(DWORD dwVnum, LPCHARACTER pkVictim, BYTE bSkillLevel)
  1958. {
  1959. FComputeSkillParty f(dwVnum, pkVictim, bSkillLevel);
  1960. if (GetParty() && GetParty()->GetNearMemberCount())
  1961. GetParty()->ForEachNearMember(f);
  1962. else
  1963. f(this);
  1965. return BATTLE_NONE;
  1966. }
  1967. #endif
  1969. // bSkillLevel ÀÎÀÚ°¡ 0ÀÌ ¾Æ´Ò °æ¿ì¿¡´Â m_abSkillLevels¸¦ »ç¿ëÇÏÁö ¾Ê°í °­Á¦·Î
  1970. // bSkillLevel·Î °è»êÇÑ´Ù.
  1971. int CHARACTER::ComputeSkill(DWORD dwVnum, LPCHARACTER pkVictim, BYTE bSkillLevel)
  1972. {
  1973. const bool bCanUseHorseSkill = CanUseHorseSkill();
  1975. // ¸»À» Ÿ°íÀÖÁö¸¸ ½ºÅ³Àº »ç¿ëÇÒ ¼ö ¾ø´Â »óŶó¸é return
  1976. if (false == bCanUseHorseSkill && true == IsRiding())
  1977. return BATTLE_NONE;
  1979. if (IsPolymorphed())
  1980. return BATTLE_NONE;
  1982. if (g_bSkillDisable)
  1983. return BATTLE_NONE;
  1985. CSkillProto* pkSk = CSkillManager::instance().Get(dwVnum);
  1987. if (!pkSk)
  1988. return BATTLE_NONE;
  1990. if (bCanUseHorseSkill && pkSk->dwType != SKILL_TYPE_HORSE)
  1991. return BATTLE_NONE;
  1993. if (!bCanUseHorseSkill && pkSk->dwType == SKILL_TYPE_HORSE)
  1994. return BATTLE_NONE;
  1997. // »ó´ë¹æ¿¡°Ô ¾²´Â °ÍÀÌ ¾Æ´Ï¸é ³ª¿¡°Ô ½á¾ß ÇÑ´Ù.
  1998. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
  1999. pkVictim = this;
  2000. // #ifdef ENABLE_WOLFMAN_CHARACTER
  2001. // else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_PARTY))
  2002. // pkVictim = this;
  2003. // #endif
  2005. if (!pkVictim)
  2006. {
  2007. if (test_server)
  2008. sys_log(0, "ComputeSkill: %s Victim == null, skill %d", GetName(), dwVnum);
  2010. return BATTLE_NONE;
  2011. }
  2013. if (pkSk->dwTargetRange && DISTANCE_SQRT(GetX() - pkVictim->GetX(), GetY() - pkVictim->GetY()) >= pkSk->dwTargetRange + 50)
  2014. {
  2015. if (test_server)
  2016. sys_log(0, "ComputeSkill: Victim too far, skill %d : %s to %s (distance %u limit %u)",
  2017. dwVnum,
  2018. GetName(),
  2019. pkVictim->GetName(),
  2020. (long)DISTANCE_SQRT(GetX() - pkVictim->GetX(), GetY() - pkVictim->GetY()),
  2021. pkSk->dwTargetRange);
  2023. return BATTLE_NONE;
  2024. }
  2026. if (0 == bSkillLevel)
  2027. {
  2028. if ((bSkillLevel = GetSkillLevel(pkSk->dwVnum)) == 0)
  2029. {
  2030. if (test_server)
  2031. sys_log(0, "ComputeSkill : name:%s vnum:%d skillLevelBySkill : %d ", GetName(), pkSk->dwVnum, bSkillLevel);
  2032. return BATTLE_NONE;
  2033. }
  2034. }
  2036. if (pkVictim->IsAffectFlag(AFF_PABEOP) && pkVictim->IsGoodAffect(dwVnum))
  2037. {
  2038. return BATTLE_NONE;
  2039. }
  2041. const float k = 1.0 * GetSkillPower(pkSk->dwVnum, bSkillLevel) * pkSk->bMaxLevel / 100;
  2043. pkSk->SetPointVar("k", k);
  2044. pkSk->kSplashAroundDamageAdjustPoly.SetVar("k", k);
  2046. if (pkSk->dwType == SKILL_TYPE_HORSE)
  2047. {
  2048. LPITEM pkBow, pkArrow;
  2049. if (1 == GetArrowAndBow(&pkBow, &pkArrow, 1))
  2050. {
  2051. pkSk->SetPointVar("atk", CalcArrowDamage(this, pkVictim, pkBow, pkArrow, true));
  2052. }
  2053. else
  2054. {
  2055. pkSk->SetPointVar("atk", CalcMeleeDamage(this, pkVictim, true, false));
  2056. }
  2057. }
  2058. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MELEE_DAMAGE))
  2059. {
  2060. pkSk->SetPointVar("atk", CalcMeleeDamage(this, pkVictim, true, false));
  2061. }
  2062. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_MAGIC_DAMAGE))
  2063. {
  2064. pkSk->SetPointVar("atk", CalcMagicDamage(this, pkVictim));
  2065. }
  2066. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_ARROW_DAMAGE))
  2067. {
  2068. LPITEM pkBow, pkArrow;
  2069. if (1 == GetArrowAndBow(&pkBow, &pkArrow, 1))
  2070. {
  2071. pkSk->SetPointVar("atk", CalcArrowDamage(this, pkVictim, pkBow, pkArrow, true));
  2072. }
  2073. else
  2074. {
  2075. pkSk->SetPointVar("atk", 0);
  2076. }
  2077. }
  2079. if (pkSk->bPointOn == POINT_MOV_SPEED)
  2080. {
  2081. pkSk->SetPointVar("maxv", pkVictim->GetLimitPoint(POINT_MOV_SPEED));
  2082. }
  2084. pkSk->SetPointVar("lv", GetLevel());
  2085. pkSk->SetPointVar("iq", GetPoint(POINT_IQ));
  2086. pkSk->SetPointVar("str", GetPoint(POINT_ST));
  2087. pkSk->SetPointVar("dex", GetPoint(POINT_DX));
  2088. pkSk->SetPointVar("con", GetPoint(POINT_HT));
  2089. pkSk->SetPointVar("maxhp", pkVictim->GetMaxHP());
  2090. pkSk->SetPointVar("maxsp", pkVictim->GetMaxSP());
  2091. pkSk->SetPointVar("chain", 0);
  2092. pkSk->SetPointVar("ar", CalcAttackRating(this, pkVictim));
  2093. pkSk->SetPointVar("def", GetPoint(POINT_DEF_GRADE));
  2094. pkSk->SetPointVar("odef", GetPoint(POINT_DEF_GRADE) - GetPoint(POINT_DEF_GRADE_BONUS));
  2095. pkSk->SetPointVar("horse_level", GetHorseLevel());
  2097. if (pkSk->bSkillAttrType != SKILL_ATTR_TYPE_NORMAL)
  2098. OnMove(true);
  2100. LPITEM pkWeapon = GetWear(WEAR_WEAPON);
  2102. SetPolyVarForAttack(this, pkSk, pkWeapon);
  2104. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
  2105. pkSk->kDurationPoly2.SetVar("k", k/*bSkillLevel*/);
  2107. int iAmount = (int) pkSk->kPointPoly.Eval();
  2108. int iAmount2 = (int) pkSk->kPointPoly2.Eval();
  2109. int iAmount3 = (int) pkSk->kPointPoly3.Eval();
  2111. if (test_server && IsPC())
  2112. sys_log(0, "iAmount: %d %d %d , atk:%f skLevel:%f k:%f GetSkillPower(%d) MaxLevel:%d Per:%f",
  2113. iAmount, iAmount2, iAmount3,
  2114. pkSk->kPointPoly.GetVar("atk"),
  2115. pkSk->kPointPoly.GetVar("k"),
  2116. k,
  2117. GetSkillPower(pkSk->dwVnum, bSkillLevel),
  2118. pkSk->bMaxLevel,
  2119. pkSk->bMaxLevel/100
  2120. );
  2122. // ADD_GRANDMASTER_SKILL
  2123. if (GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
  2124. {
  2125. iAmount = (int) pkSk->kMasterBonusPoly.Eval();
  2126. }
  2128. if (test_server && iAmount == 0 && pkSk->bPointOn != POINT_NONE)
  2129. {
  2130. ChatPacket(CHAT_TYPE_INFO, "È¿°ú°¡ ¾ø½À´Ï´Ù. ½ºÅ³ °ø½ÄÀ» È®ÀÎÇϼ¼¿ä");
  2131. }
  2132. // END_OF_ADD_GRANDMASTER_SKILL
  2134. //sys_log(0, "XXX SKILL Calc %d Amount %d", dwVnum, iAmount);
  2136. // REMOVE_BAD_AFFECT_BUG_FIX
  2137. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_REMOVE_BAD_AFFECT))
  2138. {
  2139. if (number(1, 100) <= iAmount2)
  2140. {
  2141. pkVictim->RemoveBadAffect();
  2142. }
  2143. }
  2144. // END_OF_REMOVE_BAD_AFFECT_BUG_FIX
  2146. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_ATTACK | SKILL_FLAG_USE_MELEE_DAMAGE | SKILL_FLAG_USE_MAGIC_DAMAGE) &&
  2147. !(pkSk->dwVnum == SKILL_MUYEONG && pkVictim == this) && !(pkSk->IsChargeSkill() && pkVictim == this))
  2148. {
  2149. bool bAdded = false;
  2151. if (pkSk->bPointOn == POINT_HP && iAmount < 0)
  2152. {
  2153. int iAG = 0;
  2156. FuncSplashDamage f(pkVictim->GetX(), pkVictim->GetY(), pkSk, this, iAmount, iAG, pkSk->lMaxHit, pkWeapon, m_bDisableCooltime, IsPC()?&m_SkillUseInfo[dwVnum]:NULL, GetSkillPower(dwVnum, bSkillLevel));
  2157. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  2158. {
  2159. if (pkVictim->GetSectree())
  2160. pkVictim->GetSectree()->ForEachAround(f);
  2161. }
  2162. else
  2163. {
  2164. f(pkVictim);
  2165. }
  2166. }
  2167. else
  2168. {
  2169. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
  2170. int iDur = (int) pkSk->kDurationPoly.Eval();
  2173. if (IsPC())
  2174. if (!(dwVnum >= GUILD_SKILL_START && dwVnum <= GUILD_SKILL_END)) // ±æµå ½ºÅ³Àº ÄğŸÀÓ Ã³¸®¸¦ ÇÏÁö ¾Ê´Â´Ù.
  2175. if (!m_bDisableCooltime && !m_SkillUseInfo[dwVnum].HitOnce(dwVnum) && dwVnum != SKILL_MUYEONG)
  2176. {
  2177. return BATTLE_NONE;
  2178. }
  2180. if (iDur > 0)
  2181. {
  2182. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2184. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  2185. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true);
  2186. else
  2187. {
  2188. if (pkVictim->GetSectree())
  2189. {
  2190. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn, iAmount, pkSk->dwAffectFlag, iDur, 0, true, pkSk->lMaxHit);
  2191. pkVictim->GetSectree()->ForEachAround(f);
  2192. }
  2193. }
  2194. bAdded = true;
  2195. }
  2196. }
  2198. if (pkSk->bPointOn2 != POINT_NONE && !pkSk->IsChargeSkill())
  2199. {
  2200. pkSk->kDurationPoly2.SetVar("k", k/*bSkillLevel*/);
  2201. int iDur = (int) pkSk->kDurationPoly2.Eval();
  2203. if (iDur > 0)
  2204. {
  2205. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2207. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  2208. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded);
  2209. else
  2210. {
  2211. if (pkVictim->GetSectree())
  2212. {
  2213. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur, 0, !bAdded, pkSk->lMaxHit);
  2214. pkVictim->GetSectree()->ForEachAround(f);
  2215. }
  2216. }
  2218. bAdded = true;
  2219. }
  2220. else
  2221. {
  2222. pkVictim->PointChange(pkSk->bPointOn2, iAmount2);
  2223. }
  2224. }
  2226. // ADD_GRANDMASTER_SKILL
  2227. if (pkSk->bPointOn3 != POINT_NONE && !pkSk->IsChargeSkill() && GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
  2228. {
  2229. pkSk->kDurationPoly3.SetVar("k", k/*bSkillLevel*/);
  2230. int iDur = (int) pkSk->kDurationPoly3.Eval();
  2233. if (iDur > 0)
  2234. {
  2235. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2237. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  2238. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded);
  2239. else
  2240. {
  2241. if (pkVictim->GetSectree())
  2242. {
  2243. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded, pkSk->lMaxHit);
  2244. pkVictim->GetSectree()->ForEachAround(f);
  2245. }
  2246. }
  2248. bAdded = true;
  2249. }
  2250. else
  2251. {
  2252. pkVictim->PointChange(pkSk->bPointOn3, iAmount3);
  2253. }
  2254. }
  2255. // END_OF_ADD_GRANDMASTER_SKILL
  2257. return BATTLE_DAMAGE;
  2258. }
  2259. else
  2260. {
  2261. if (dwVnum == SKILL_MUYEONG)
  2262. {
  2263. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
  2264. pkSk->kDurationSPCostPoly.SetVar("k", k/*bSkillLevel*/);
  2266. int iDur = (long) pkSk->kDurationPoly.Eval();
  2267. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2269. if (pkVictim == this)
  2270. AddAffect(dwVnum,
  2271. POINT_NONE, 0,
  2272. AFF_MUYEONG,
  2273. iDur,
  2274. (long) pkSk->kDurationSPCostPoly.Eval(),
  2275. true);
  2277. return BATTLE_NONE;
  2278. }
  2280. bool bAdded = false;
  2281. pkSk->kDurationPoly.SetVar("k", k/*bSkillLevel*/);
  2282. int iDur = (int) pkSk->kDurationPoly.Eval();
  2284. if (iDur > 0)
  2285. {
  2286. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2287. // AffectFlag°¡ ¾ø°Å³ª, toggle ÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó¸é..
  2288. pkSk->kDurationSPCostPoly.SetVar("k", k/*bSkillLevel*/);
  2290. if (pkSk->bPointOn2 != POINT_NONE)
  2291. {
  2292. pkVictim->RemoveAffect(pkSk->dwVnum);
  2294. int iDur2 = (int) pkSk->kDurationPoly2.Eval();
  2296. if (iDur2 > 0)
  2297. {
  2298. if (test_server)
  2299. sys_log(0, "SKILL_AFFECT: %s %s Dur:%d To:%d Amount:%d",
  2300. GetName(),
  2301. pkSk->szName,
  2302. iDur2,
  2303. pkSk->bPointOn2,
  2304. iAmount2);
  2306. iDur2 += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2307. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur2, 0, false);
  2308. }
  2309. else
  2310. {
  2311. pkVictim->PointChange(pkSk->bPointOn2, iAmount2);
  2312. }
  2314. DWORD affact_flag = pkSk->dwAffectFlag;
  2316. // ADD_GRANDMASTER_SKILL
  2317. if ((pkSk->dwVnum == SKILL_CHUNKEON && GetUsedSkillMasterType(pkSk->dwVnum) < SKILL_GRAND_MASTER))
  2318. affact_flag = AFF_CHEONGEUN_WITH_FALL;
  2319. // END_OF_ADD_GRANDMASTER_SKILL
  2321. pkVictim->AddAffect(pkSk->dwVnum,
  2322. pkSk->bPointOn,
  2323. iAmount,
  2324. affact_flag,
  2325. iDur,
  2326. (long) pkSk->kDurationSPCostPoly.Eval(),
  2327. false);
  2328. }
  2329. else
  2330. {
  2331. if (test_server)
  2332. sys_log(0, "SKILL_AFFECT: %s %s Dur:%d To:%d Amount:%d",
  2333. GetName(),
  2334. pkSk->szName,
  2335. iDur,
  2336. pkSk->bPointOn,
  2337. iAmount);
  2339. pkVictim->AddAffect(pkSk->dwVnum,
  2340. pkSk->bPointOn,
  2341. iAmount,
  2342. pkSk->dwAffectFlag,
  2343. iDur,
  2344. (long) pkSk->kDurationSPCostPoly.Eval(),
  2345. // ADD_GRANDMASTER_SKILL
  2346. !bAdded);
  2347. // END_OF_ADD_GRANDMASTER_SKILL
  2348. }
  2350. bAdded = true;
  2351. }
  2352. else
  2353. {
  2354. if (!pkSk->IsChargeSkill())
  2355. pkVictim->PointChange(pkSk->bPointOn, iAmount);
  2357. if (pkSk->bPointOn2 != POINT_NONE)
  2358. {
  2359. pkVictim->RemoveAffect(pkSk->dwVnum);
  2361. int iDur2 = (int) pkSk->kDurationPoly2.Eval();
  2363. if (iDur2 > 0)
  2364. {
  2365. iDur2 += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2367. if (pkSk->IsChargeSkill())
  2368. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, AFF_TANHWAN_DASH, iDur2, 0, false);
  2369. else
  2370. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn2, iAmount2, pkSk->dwAffectFlag2, iDur2, 0, false);
  2371. }
  2372. else
  2373. {
  2374. pkVictim->PointChange(pkSk->bPointOn2, iAmount2);
  2375. }
  2377. }
  2378. }
  2380. // ADD_GRANDMASTER_SKILL
  2381. if (pkSk->bPointOn3 != POINT_NONE && !pkSk->IsChargeSkill() && GetUsedSkillMasterType(pkSk->dwVnum) >= SKILL_GRAND_MASTER)
  2382. {
  2384. pkSk->kDurationPoly3.SetVar("k", k/*bSkillLevel*/);
  2385. int iDur = (int) pkSk->kDurationPoly3.Eval();
  2387. sys_log(0, "try third %u %d %d %d 1894", pkSk->dwVnum, pkSk->bPointOn3, iDur, iAmount3);
  2389. if (iDur > 0)
  2390. {
  2391. iDur += GetPoint(POINT_PARTY_BUFFER_BONUS);
  2393. if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_SPLASH))
  2394. pkVictim->AddAffect(pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded);
  2395. else
  2396. {
  2397. if (pkVictim->GetSectree())
  2398. {
  2399. FuncSplashAffect f(this, pkVictim->GetX(), pkVictim->GetY(), pkSk->iSplashRange, pkSk->dwVnum, pkSk->bPointOn3, iAmount3, /*pkSk->dwAffectFlag3*/ 0, iDur, 0, !bAdded, pkSk->lMaxHit);
  2400. pkVictim->GetSectree()->ForEachAround(f);
  2401. }
  2402. }
  2404. bAdded = true;
  2405. }
  2406. else
  2407. {
  2408. pkVictim->PointChange(pkSk->bPointOn3, iAmount3);
  2409. }
  2410. }
  2411. // END_OF_ADD_GRANDMASTER_SKILL
  2413. return BATTLE_NONE;
  2414. }
  2415. }
  2417. bool CHARACTER::UseSkill(DWORD dwVnum, LPCHARACTER pkVictim, bool bUseGrandMaster)
  2418. {
  2419. if (false == CanUseSkill(dwVnum))
  2420. return false;
  2421. #ifdef ENABLE_PVP_ADVANCED
  2422. switch (dwVnum)
  2423. {
  2424. case 94:
  2425. case 95:
  2426. case 96:
  2427. case 109:
  2428. case 110:
  2429. case 111:
  2430. {
  2431. if (this && pkVictim)
  2432. {
  2433. if (this != pkVictim && this->GetDesc() && pkVictim->GetDesc())
  2434. {
  2435. if (pkVictim->GetQuestFlag(BLOCK_BUFF))
  2436. {
  2437. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("duel_block_victim_buff"), pkVictim->GetName());
  2438. return false;
  2439. }
  2440. }
  2441. }
  2442. }
  2443. break;
  2444. }
  2445. #endif
  2447. // NO_GRANDMASTER
  2448. if (test_server)
  2449. {
  2450. if (quest::CQuestManager::instance().GetEventFlag("no_grand_master"))
  2451. {
  2452. bUseGrandMaster = false;
  2453. }
  2454. }
  2455. // END_OF_NO_GRANDMASTER
  2457. if (g_bSkillDisable)
  2458. return false;
  2460. if (IsObserverMode())
  2461. return false;
  2463. if (!CanMove())
  2464. return false;
  2466. if (IsPolymorphed())
  2467. return false;
  2469. const bool bCanUseHorseSkill = CanUseHorseSkill();
  2472. if (dwVnum == SKILL_HORSE_SUMMON)
  2473. {
  2474. if (GetSkillLevel(dwVnum) == 0)
  2475. return false;
  2477. if (GetHorseLevel() <= 0)
  2478. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»ÀÌ ¾ø½À´Ï´Ù. ¸¶±Â°£ °æºñº´À» ã¾Æ°¡¼¼¿ä."));
  2479. else
  2480. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸» ¼Òȯ ¾ÆÀÌÅÛÀ» »ç¿ëÇϼ¼¿ä."));
  2482. return true;
  2483. }
  2485. // ¸»À» Ÿ°íÀÖÁö¸¸ ½ºÅ³Àº »ç¿ëÇÒ ¼ö ¾ø´Â »óŶó¸é return false
  2486. if (false == bCanUseHorseSkill && true == IsRiding())
  2487. return false;
  2489. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
  2490. sys_log(0, "%s: USE_SKILL: %d pkVictim %p", GetName(), dwVnum, get_pointer(pkVictim));
  2492. if (!pkSk)
  2493. return false;
  2495. if (bCanUseHorseSkill && pkSk->dwType != SKILL_TYPE_HORSE)
  2496. return BATTLE_NONE;
  2498. if (!bCanUseHorseSkill && pkSk->dwType == SKILL_TYPE_HORSE)
  2499. return BATTLE_NONE;
  2501. if (GetSkillLevel(dwVnum) == 0)
  2502. return false;
  2505. // NO_GRANDMASTER
  2506. if (GetSkillMasterType(dwVnum) < SKILL_GRAND_MASTER)
  2507. bUseGrandMaster = false;
  2508. // END_OF_NO_GRANDMASTER
  2510. // MINING
  2511. if (GetWear(WEAR_WEAPON) && (GetWear(WEAR_WEAPON)->GetType() == ITEM_ROD || GetWear(WEAR_WEAPON)->GetType() == ITEM_PICK))
  2512. return false;
  2513. // END_OF_MINING
  2515. m_SkillUseInfo[dwVnum].TargetVIDMap.clear();
  2517. if (pkSk->IsChargeSkill())
  2518. {
  2519. if ((IsAffectFlag(AFF_TANHWAN_DASH)) || (pkVictim && (pkVictim != this)))
  2520. {
  2521. if (!pkVictim)
  2522. return false;
  2524. if (!IsAffectFlag(AFF_TANHWAN_DASH))
  2525. {
  2526. if (!UseSkill(dwVnum, this))
  2527. return false;
  2528. }
  2530. m_SkillUseInfo[dwVnum].SetMainTargetVID(pkVictim->GetVID());
  2531. // DASH »óÅÂÀÇ ÅºÈ¯°İÀº °ø°İ±â¼ú
  2532. ComputeSkill(dwVnum, pkVictim);
  2533. RemoveAffect(dwVnum);
  2534. return true;
  2535. }
  2536. }
  2538. if (dwVnum == SKILL_COMBO)
  2539. {
  2540. if (m_bComboIndex)
  2541. m_bComboIndex = 0;
  2542. else
  2543. m_bComboIndex = GetSkillLevel(SKILL_COMBO);
  2545. ChatPacket(CHAT_TYPE_COMMAND, "combo %d", m_bComboIndex);
  2546. return true;
  2547. }
  2549. // Toggle ÇÒ ¶§´Â SP¸¦ ¾²Áö ¾ÊÀ½ (SelfOnly·Î ±¸ºĞ)
  2550. if ((0 != pkSk->dwAffectFlag || pkSk->dwVnum == SKILL_MUYEONG) && (pkSk->dwFlag & SKILL_FLAG_TOGGLE) && RemoveAffect(pkSk->dwVnum))
  2551. {
  2552. return true;
  2553. }
  2555. if (IsAffectFlag(AFF_REVIVE_INVISIBLE))
  2556. RemoveAffect(AFFECT_REVIVE_INVISIBLE);
  2558. const float k = 1.0 * GetSkillPower(pkSk->dwVnum) * pkSk->bMaxLevel / 100;
  2560. pkSk->SetPointVar("k", k);
  2561. pkSk->kSplashAroundDamageAdjustPoly.SetVar("k", k);
  2563. // ÄğŸÀÓ Ã¼Å©
  2564. pkSk->kCooldownPoly.SetVar("k", k);
  2565. int iCooltime = (int) pkSk->kCooldownPoly.Eval();
  2566. int lMaxHit = pkSk->lMaxHit ? pkSk->lMaxHit : -1;
  2568. pkSk->SetSPCostVar("k", k);
  2570. DWORD dwCur = get_dword_time();
  2572. if (dwVnum == SKILL_TERROR && m_SkillUseInfo[dwVnum].bUsed && m_SkillUseInfo[dwVnum].dwNextSkillUsableTime > dwCur )
  2573. {
  2574. sys_log(0, " SKILL_TERROR's Cooltime is not delta over %u", m_SkillUseInfo[dwVnum].dwNextSkillUsableTime - dwCur );
  2575. return false;
  2576. }
  2578. int iNeededSP = 0;
  2580. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_USE_HP_AS_COST))
  2581. {
  2582. pkSk->SetSPCostVar("maxhp", GetMaxHP());
  2583. pkSk->SetSPCostVar("v", GetHP());
  2584. iNeededSP = (int) pkSk->kSPCostPoly.Eval();
  2586. // ADD_GRANDMASTER_SKILL
  2587. if (GetSkillMasterType(dwVnum) >= SKILL_GRAND_MASTER && bUseGrandMaster)
  2588. {
  2589. iNeededSP = (int) pkSk->kGrandMasterAddSPCostPoly.Eval();
  2590. }
  2591. // END_OF_ADD_GRANDMASTER_SKILL
  2593. if (GetHP() < iNeededSP)
  2594. return false;
  2596. PointChange(POINT_HP, -iNeededSP);
  2597. }
  2598. else
  2599. {
  2600. // SKILL_FOMULA_REFACTORING
  2601. pkSk->SetSPCostVar("maxhp", GetMaxHP());
  2602. pkSk->SetSPCostVar("maxv", GetMaxSP());
  2603. pkSk->SetSPCostVar("v", GetSP());
  2605. iNeededSP = (int) pkSk->kSPCostPoly.Eval();
  2607. if (GetSkillMasterType(dwVnum) >= SKILL_GRAND_MASTER && bUseGrandMaster)
  2608. {
  2609. iNeededSP = (int) pkSk->kGrandMasterAddSPCostPoly.Eval();
  2610. }
  2611. // END_OF_SKILL_FOMULA_REFACTORING
  2613. if (GetSP() < iNeededSP)
  2614. return false;
  2616. if (test_server)
  2617. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s SP¼Ò¸ğ: %d"), pkSk->szName, iNeededSP);
  2619. PointChange(POINT_SP, -iNeededSP);
  2620. }
  2622. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
  2623. pkVictim = this;
  2624. #ifdef ENABLE_WOLFMAN_CHARACTER
  2625. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_PARTY))
  2626. pkVictim = this;
  2627. #endif
  2629. if ((pkSk->dwVnum == SKILL_MUYEONG) || (pkSk->IsChargeSkill() && !IsAffectFlag(AFF_TANHWAN_DASH) && !pkVictim))
  2630. {
  2631. // óÀ½ »ç¿ëÇÏ´Â ¹«¿µÁøÀº Àڽſ¡°Ô Affect¸¦ ºÙÀδÙ.
  2632. pkVictim = this;
  2633. }
  2635. int iSplashCount = 1;
  2637. if (false == m_bDisableCooltime)
  2638. {
  2639. if (false ==
  2640. m_SkillUseInfo[dwVnum].UseSkill(
  2641. bUseGrandMaster,
  2642. (NULL != pkVictim && SKILL_HORSE_WILDATTACK != dwVnum) ? pkVictim->GetVID() : NULL,
  2643. ComputeCooltime(iCooltime * 1000),
  2644. iSplashCount,
  2645. lMaxHit))
  2646. {
  2647. if (test_server)
  2648. ChatPacket(CHAT_TYPE_NOTICE, "cooltime not finished %s %d", pkSk->szName, iCooltime);
  2650. return false;
  2651. }
  2652. }
  2654. if (dwVnum == SKILL_CHAIN)
  2655. {
  2656. ResetChainLightningIndex();
  2657. AddChainLightningExcept(pkVictim);
  2658. }
  2661. if (IS_SET(pkSk->dwFlag, SKILL_FLAG_SELFONLY))
  2662. ComputeSkill(dwVnum, this);
  2663. #ifdef ENABLE_WOLFMAN_CHARACTER
  2664. else if (IS_SET(pkSk->dwFlag, SKILL_FLAG_PARTY))
  2665. ComputeSkillParty(dwVnum, this);
  2666. #endif
  2667. else if (!IS_SET(pkSk->dwFlag, SKILL_FLAG_ATTACK))
  2668. ComputeSkill(dwVnum, pkVictim);
  2669. else if (dwVnum == SKILL_BYEURAK)
  2670. ComputeSkill(dwVnum, pkVictim);
  2671. else if (dwVnum == SKILL_MUYEONG || pkSk->IsChargeSkill())
  2672. ComputeSkill(dwVnum, pkVictim);
  2674. m_dwLastSkillTime = get_dword_time();
  2676. return true;
  2677. }
  2679. int CHARACTER::GetUsedSkillMasterType(DWORD dwVnum)
  2680. {
  2681. const TSkillUseInfo& rInfo = m_SkillUseInfo[dwVnum];
  2683. if (GetSkillMasterType(dwVnum) < SKILL_GRAND_MASTER)
  2684. return GetSkillMasterType(dwVnum);
  2686. if (rInfo.isGrandMaster)
  2687. return GetSkillMasterType(dwVnum);
  2689. return MIN(GetSkillMasterType(dwVnum), SKILL_MASTER);
  2690. }
  2692. int CHARACTER::GetSkillMasterType(DWORD dwVnum) const
  2693. {
  2694. if (!IsPC())
  2695. return 0;
  2697. if (dwVnum >= SKILL_MAX_NUM)
  2698. {
  2699. sys_err("%s skill vnum overflow %u", GetName(), dwVnum);
  2700. return 0;
  2701. }
  2703. return m_pSkillLevels ? m_pSkillLevels[dwVnum].bMasterType:SKILL_NORMAL;
  2704. }
  2706. int CHARACTER::GetSkillPower(DWORD dwVnum, BYTE bLevel) const
  2707. {
  2708. // Àξî¹İÁö ¾ÆÀÌÅÛ
  2709. if (dwVnum >= SKILL_LANGUAGE1 && dwVnum <= SKILL_LANGUAGE3 && IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
  2710. {
  2711. return 100;
  2712. }
  2714. if (dwVnum >= GUILD_SKILL_START && dwVnum <= GUILD_SKILL_END)
  2715. {
  2716. if (GetGuild())
  2717. return 100 * GetGuild()->GetSkillLevel(dwVnum) / 7 / 7;
  2718. else
  2719. return 0;
  2720. }
  2722. if (bLevel)
  2723. {
  2724. //SKILL_POWER_BY_LEVEL
  2725. return GetSkillPowerByLevel(bLevel, true);
  2726. //END_SKILL_POWER_BY_LEVEL;
  2727. }
  2729. if (dwVnum >= SKILL_MAX_NUM)
  2730. {
  2731. sys_err("%s skill vnum overflow %u", GetName(), dwVnum);
  2732. return 0;
  2733. }
  2735. //SKILL_POWER_BY_LEVEL
  2736. return GetSkillPowerByLevel(GetSkillLevel(dwVnum));
  2737. //SKILL_POWER_BY_LEVEL
  2738. }
  2740. int CHARACTER::GetSkillLevel(DWORD dwVnum) const
  2741. {
  2742. if (dwVnum >= SKILL_MAX_NUM)
  2743. {
  2744. sys_err("%s skill vnum overflow %u", GetName(), dwVnum);
  2745. sys_log(0, "%s skill vnum overflow %u", GetName(), dwVnum);
  2746. return 0;
  2747. }
  2749. return MIN(SKILL_MAX_LEVEL, m_pSkillLevels ? m_pSkillLevels[dwVnum].bLevel : 0);
  2750. }
  2752. EVENTFUNC(skill_muyoung_event)
  2753. {
  2754. char_event_info* info = dynamic_cast<char_event_info*>( event->info );
  2756. if ( info == NULL )
  2757. {
  2758. sys_err( "skill_muyoung_event> <Factor> Null pointer" );
  2759. return 0;
  2760. }
  2762. LPCHARACTER ch = info->ch;
  2764. if (ch == NULL) { // <Factor>
  2765. return 0;
  2766. }
  2768. if (!ch->IsAffectFlag(AFF_MUYEONG))
  2769. {
  2770. ch->StopMuyeongEvent();
  2771. return 0;
  2772. }
  2774. // 1. Find Victim
  2775. FFindNearVictim f(ch, ch);
  2776. if (ch->GetSectree())
  2777. {
  2778. ch->GetSectree()->ForEachAround(f);
  2779. // 2. Shoot!
  2780. if (f.GetVictim())
  2781. {
  2782. ch->CreateFly(FLY_SKILL_MUYEONG, f.GetVictim());
  2783. ch->ComputeSkill(SKILL_MUYEONG, f.GetVictim());
  2784. }
  2785. }
  2787. return PASSES_PER_SEC(3);
  2788. }
  2790. void CHARACTER::StartMuyeongEvent()
  2791. {
  2792. if (m_pkMuyeongEvent)
  2793. return;
  2795. char_event_info* info = AllocEventInfo<char_event_info>();
  2797. info->ch = this;
  2798. m_pkMuyeongEvent = event_create(skill_muyoung_event, info, PASSES_PER_SEC(1));
  2799. }
  2801. void CHARACTER::StopMuyeongEvent()
  2802. {
  2803. event_cancel(&m_pkMuyeongEvent);
  2804. }
  2806. void CHARACTER::SkillLearnWaitMoreTimeMessage(DWORD ms)
  2807. {
  2808. //const char* str = "";
  2809. //
  2810. if (ms < 3 * 60)
  2811. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¸ö ¼ÓÀÌ ¶ß°Ì±º. ÇÏÁö¸¸ ¾ÆÁÖ Æí¾ÈÇØ. ÀÌ´ë·Î ±â¸¦ ¾ÈÁ¤½ÃÅ°ÀÚ."));
  2812. else if (ms < 5 * 60)
  2813. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("±×·¡, õõÈ÷. Á»´õ õõÈ÷, ±×·¯³ª ¸·Èû ¾øÀÌ ºü¸£°Ô!"));
  2814. else if (ms < 10 * 60) // 10ºĞ
  2815. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("±×·¡, ÀÌ ´À³¦À̾ß. ü³»¿¡ ±â°¡ ¾ÆÁÖ Ã游ÇØ."));
  2816. else if (ms < 30 * 60) // 30ºĞ
  2817. {
  2818. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("´Ù Àоú´Ù! ÀÌÁ¦ ºñ±Ş¿¡ ÀûÇôÀÖ´Â ´ë·Î Àü½Å¿¡ ±â¸¦ µ¹¸®±â¸¸ Çϸé,"));
  2819. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("±×°ÍÀ¸·Î ¼ö·ÃÀº ³¡³­ °Å¾ß!"));
  2820. }
  2821. else if (ms < 1 * 3600) // 1½Ã°£
  2822. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÀÌÁ¦ Ã¥ÀÇ ¸¶Áö¸· ÀåÀ̾ß! ¼ö·ÃÀÇ ³¡ÀÌ ´«¿¡ º¸ÀÌ°í ÀÖ¾î!"));
  2823. else if (ms < 2 * 3600) // 2½Ã°£
  2824. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¾ó¸¶ ¾È ³²¾Ò¾î! Á¶±İ¸¸ ´õ!"));
  2825. else if (ms < 3 * 3600)
  2826. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÁÁ¾Ò¾î! Á¶±İ¸¸ ´õ ÀĞÀ¸¸é ³¡ÀÌ´Ù!"));
  2827. else if (ms < 6 * 3600)
  2828. {
  2829. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("Ã¥Àåµµ ÀÌÁ¦ ¾ó¸¶ ³²Áö ¾Ê¾Ò±º."));
  2830. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¹º°¡ ¸ö ¾È¿¡ ÈûÀÌ »ı±â´Â ±âºĞÀÎ °É."));
  2831. }
  2832. else if (ms < 12 * 3600)
  2833. {
  2834. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÀÌÁ¦ Á» ½½½½ °¡´ÚÀÌ ÀâÈ÷´Â °Í °°Àºµ¥."));
  2835. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÁÁ¾Æ, ÀÌ ±â¼¼·Î °è¼Ó ³ª°£´Ù!"));
  2836. }
  2837. else if (ms < 18 * 3600)
  2838. {
  2839. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("¾Æ´Ï ¾î¶»°Ô µÈ °Ô Á¾ÀÏ Àо ¸Ó¸®¿¡ ¾È µé¾î¿À³Ä."));
  2840. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("°øºÎÇϱ⠽ȾîÁö³×."));
  2841. }
  2842. else //if (ms < 2 * 86400)
  2843. {
  2844. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("»ı°¢¸¸Å­ ÀбⰡ ½±Áö°¡ ¾Ê±º. ÀÌÇصµ ¾î·Æ°í ³»¿ëµµ ³­ÇØÇØ."));
  2845. ChatPacket(CHAT_TYPE_TALKING, "%s", LC_TEXT("ÀÌ·¡¼­¾ß °øºÎ°¡ ¾ÈµÈ´Ù±¸."));
  2846. }
  2847. /*
  2848. str = "30%";
  2849. else if (ms < 3 * 86400)
  2850. str = "10%";
  2851. else if (ms < 4 * 86400)
  2852. str = "5%";
  2853. else
  2854. str = "0%";*/
  2856. //ChatPacket(CHAT_TYPE_TALKING, "%s", str);
  2857. }
  2859. void CHARACTER::DisableCooltime()
  2860. {
  2861. m_bDisableCooltime = true;
  2862. }
  2864. bool CHARACTER::HasMobSkill() const
  2865. {
  2866. return CountMobSkill() > 0;
  2867. }
  2869. size_t CHARACTER::CountMobSkill() const
  2870. {
  2871. if (!m_pkMobData)
  2872. return 0;
  2874. size_t c = 0;
  2876. for (size_t i = 0; i < MOB_SKILL_MAX_NUM; ++i)
  2877. if (m_pkMobData->m_table.Skills[i].dwVnum)
  2878. ++c;
  2880. return c;
  2881. }
  2883. const TMobSkillInfo* CHARACTER::GetMobSkill(unsigned int idx) const
  2884. {
  2885. if (idx >= MOB_SKILL_MAX_NUM)
  2886. return NULL;
  2888. if (!m_pkMobData)
  2889. return NULL;
  2891. if (0 == m_pkMobData->m_table.Skills[idx].dwVnum)
  2892. return NULL;
  2894. return &m_pkMobData->m_mobSkillInfo[idx];
  2895. }
  2897. bool CHARACTER::CanUseMobSkill(unsigned int idx) const
  2898. {
  2899. const TMobSkillInfo* pInfo = GetMobSkill(idx);
  2901. if (!pInfo)
  2902. return false;
  2904. if (m_adwMobSkillCooltime[idx] > get_dword_time())
  2905. return false;
  2907. if (number(0, 1))
  2908. return false;
  2910. return true;
  2911. }
  2913. EVENTINFO(mob_skill_event_info)
  2914. {
  2915. DynamicCharacterPtr ch;
  2916. PIXEL_POSITION pos;
  2917. DWORD vnum;
  2918. int index;
  2919. BYTE level;
  2921. mob_skill_event_info()
  2922. : ch()
  2923. , pos()
  2924. , vnum(0)
  2925. , index(0)
  2926. , level(0)
  2927. {
  2928. }
  2929. };
  2931. EVENTFUNC(mob_skill_hit_event)
  2932. {
  2933. mob_skill_event_info * info = dynamic_cast<mob_skill_event_info *>( event->info );
  2935. if ( info == NULL )
  2936. {
  2937. sys_err( "mob_skill_event_info> <Factor> Null pointer" );
  2938. return 0;
  2939. }
  2941. // <Factor>
  2942. LPCHARACTER ch = info->ch;
  2943. if (ch == NULL) {
  2944. return 0;
  2945. }
  2947. ch->ComputeSkillAtPosition(info->vnum, info->pos, info->level);
  2948. ch->m_mapMobSkillEvent.erase(info->index);
  2950. return 0;
  2951. }
  2953. #ifdef __VERSION_162__
  2954. struct FHealerParty
  2955. {
  2956. FHealerParty(LPCHARACTER pkHealer) : m_pkHealer(pkHealer) {}
  2958. void operator () (LPCHARACTER ch)
  2959. {
  2960. int iRevive = (int)(m_pkHealer->GetMaxHP() / 100 * 15);
  2961. int iHP = (ch->GetMaxHP() >= ch->GetHP() + iRevive) ? (int)(ch->GetHP() + iRevive) : (int)(ch->GetMaxHP());
  2962. ch->SetHP(iHP);
  2963. ch->EffectPacket(SE_EFFECT_HEALER);
  2964. sys_log(0, "FHealerParty: %s (pointer: %p) heal the HP of %s (pointer: %p) with %d (new HP: %d).", m_pkHealer->GetName(), get_pointer(m_pkHealer), ch->GetName(), get_pointer(ch), iRevive, ch->GetHP());
  2965. }
  2967. LPCHARACTER m_pkHealer;
  2968. };
  2969. #endif
  2971. bool CHARACTER::UseMobSkill(unsigned int idx)
  2972. {
  2973. if (IsPC())
  2974. return false;
  2976. const TMobSkillInfo* pInfo = GetMobSkill(idx);
  2978. if (!pInfo)
  2979. return false;
  2981. DWORD dwVnum = pInfo->dwSkillVnum;
  2982. CSkillProto * pkSk = CSkillManager::instance().Get(dwVnum);
  2984. if (!pkSk)
  2985. return false;
  2987. const float k = 1.0 * GetSkillPower(pkSk->dwVnum, pInfo->bSkillLevel) * pkSk->bMaxLevel / 100;
  2989. pkSk->kCooldownPoly.SetVar("k", k);
  2990. int iCooltime = (int) (pkSk->kCooldownPoly.Eval() * 1000);
  2992. m_adwMobSkillCooltime[idx] = get_dword_time() + iCooltime;
  2994. sys_log(0, "USE_MOB_SKILL: %s idx %d vnum %u cooltime %d", GetName(), idx, dwVnum, iCooltime);
  2996. #ifdef __VERSION_162__
  2997. if ((IsMonster()) && (pkSk->dwVnum == HEALING_SKILL_VNUM))
  2998. {
  2999. LPPARTY pkParty = GetParty();
  3000. if ((pkParty) && (IS_SET(pkSk->dwFlag, SKILL_FLAG_PARTY)))
  3001. {
  3002. FHealerParty f(this);
  3003. pkParty->ForEachMemberPtr(f);
  3004. }
  3005. else
  3006. {
  3007. int iRevive = (int)(GetMaxHP() / 100 * 15);
  3008. int iHP = (GetMaxHP() >= GetHP() + iRevive) ? (int)(GetHP() + iRevive) : (int)(GetMaxHP());
  3009. SetHP(iHP);
  3010. EffectPacket(SE_EFFECT_HEALER);
  3011. sys_log(0, "FHealer: %s (pointer: %p) heal their HP with %d (new HP: %d).", GetName(), get_pointer(this), iRevive, GetHP());
  3012. }
  3014. return true;
  3015. }
  3016. #endif
  3018. if (m_pkMobData->m_mobSkillInfo[idx].vecSplashAttack.empty())
  3019. {
  3020. sys_err("No skill hit data for mob %s index %d", GetName(), idx);
  3021. return false;
  3022. }
  3024. for (size_t i = 0; i < m_pkMobData->m_mobSkillInfo[idx].vecSplashAttack.size(); i++)
  3025. {
  3026. PIXEL_POSITION pos = GetXYZ();
  3027. const TMobSplashAttackInfo& rInfo = m_pkMobData->m_mobSkillInfo[idx].vecSplashAttack[i];
  3029. if (rInfo.dwHitDistance)
  3030. {
  3031. float fx, fy;
  3032. GetDeltaByDegree(GetRotation(), rInfo.dwHitDistance, &fx, &fy);
  3033. pos.x += (long) fx;
  3034. pos.y += (long) fy;
  3035. }
  3037. if (rInfo.dwTiming)
  3038. {
  3039. if (test_server)
  3040. sys_log(0, " timing %ums", rInfo.dwTiming);
  3042. mob_skill_event_info* info = AllocEventInfo<mob_skill_event_info>();
  3044. info->ch = this;
  3045. info->pos = pos;
  3046. info->level = pInfo->bSkillLevel;
  3047. info->vnum = dwVnum;
  3048. info->index = i;
  3050. // <Factor> Cancel existing event first
  3051. itertype(m_mapMobSkillEvent) it = m_mapMobSkillEvent.find(i);
  3052. if (it != m_mapMobSkillEvent.end()) {
  3053. LPEVENT existing = it->second;
  3054. event_cancel(&existing);
  3055. m_mapMobSkillEvent.erase(it);
  3056. }
  3058. m_mapMobSkillEvent.insert(std::make_pair(i, event_create(mob_skill_hit_event, info, PASSES_PER_SEC(rInfo.dwTiming) / 1000)));
  3059. }
  3060. else
  3061. {
  3062. ComputeSkillAtPosition(dwVnum, pos, pInfo->bSkillLevel);
  3063. }
  3064. }
  3066. return true;
  3067. }
  3069. void CHARACTER::ResetMobSkillCooltime()
  3070. {
  3071. memset(m_adwMobSkillCooltime, 0, sizeof(m_adwMobSkillCooltime));
  3072. }
  3074. bool CHARACTER::IsUsableSkillMotion(DWORD dwMotionIndex) const
  3075. {
  3076. DWORD selfJobGroup = (GetJob()+1) * 10 + GetSkillGroup();
  3077. #ifdef ENABLE_WOLFMAN_CHARACTER
  3078. const DWORD SKILL_NUM = 176;
  3079. #else
  3080. const DWORD SKILL_NUM = 158;
  3081. #endif
  3082. static DWORD s_anSkill2JobGroup[SKILL_NUM] = {
  3083. 0, // common_skill 0
  3084. 11, // job_skill 1
  3085. 11, // job_skill 2
  3086. 11, // job_skill 3
  3087. 11, // job_skill 4
  3088. 11, // job_skill 5
  3089. 11, // job_skill 6
  3090. 0, // common_skill 7
  3091. 0, // common_skill 8
  3092. 0, // common_skill 9
  3093. 0, // common_skill 10
  3094. 0, // common_skill 11
  3095. 0, // common_skill 12
  3096. 0, // common_skill 13
  3097. 0, // common_skill 14
  3098. 0, // common_skill 15
  3099. 12, // job_skill 16
  3100. 12, // job_skill 17
  3101. 12, // job_skill 18
  3102. 12, // job_skill 19
  3103. 12, // job_skill 20
  3104. 12, // job_skill 21
  3105. 0, // common_skill 22
  3106. 0, // common_skill 23
  3107. 0, // common_skill 24
  3108. 0, // common_skill 25
  3109. 0, // common_skill 26
  3110. 0, // common_skill 27
  3111. 0, // common_skill 28
  3112. 0, // common_skill 29
  3113. 0, // common_skill 30
  3114. 21, // job_skill 31
  3115. 21, // job_skill 32
  3116. 21, // job_skill 33
  3117. 21, // job_skill 34
  3118. 21, // job_skill 35
  3119. 21, // job_skill 36
  3120. 0, // common_skill 37
  3121. 0, // common_skill 38
  3122. 0, // common_skill 39
  3123. 0, // common_skill 40
  3124. 0, // common_skill 41
  3125. 0, // common_skill 42
  3126. 0, // common_skill 43
  3127. 0, // common_skill 44
  3128. 0, // common_skill 45
  3129. 22, // job_skill 46
  3130. 22, // job_skill 47
  3131. 22, // job_skill 48
  3132. 22, // job_skill 49
  3133. 22, // job_skill 50
  3134. 22, // job_skill 51
  3135. 0, // common_skill 52
  3136. 0, // common_skill 53
  3137. 0, // common_skill 54
  3138. 0, // common_skill 55
  3139. 0, // common_skill 56
  3140. 0, // common_skill 57
  3141. 0, // common_skill 58
  3142. 0, // common_skill 59
  3143. 0, // common_skill 60
  3144. 31, // job_skill 61
  3145. 31, // job_skill 62
  3146. 31, // job_skill 63
  3147. 31, // job_skill 64
  3148. 31, // job_skill 65
  3149. 31, // job_skill 66
  3150. 0, // common_skill 67
  3151. 0, // common_skill 68
  3152. 0, // common_skill 69
  3153. 0, // common_skill 70
  3154. 0, // common_skill 71
  3155. 0, // common_skill 72
  3156. 0, // common_skill 73
  3157. 0, // common_skill 74
  3158. 0, // common_skill 75
  3159. 32, // job_skill 76
  3160. 32, // job_skill 77
  3161. 32, // job_skill 78
  3162. 32, // job_skill 79
  3163. 32, // job_skill 80
  3164. 32, // job_skill 81
  3165. 0, // common_skill 82
  3166. 0, // common_skill 83
  3167. 0, // common_skill 84
  3168. 0, // common_skill 85
  3169. 0, // common_skill 86
  3170. 0, // common_skill 87
  3171. 0, // common_skill 88
  3172. 0, // common_skill 89
  3173. 0, // common_skill 90
  3174. 41, // job_skill 91
  3175. 41, // job_skill 92
  3176. 41, // job_skill 93
  3177. 41, // job_skill 94
  3178. 41, // job_skill 95
  3179. 41, // job_skill 96
  3180. 0, // common_skill 97
  3181. 0, // common_skill 98
  3182. 0, // common_skill 99
  3183. 0, // common_skill 100
  3184. 0, // common_skill 101
  3185. 0, // common_skill 102
  3186. 0, // common_skill 103
  3187. 0, // common_skill 104
  3188. 0, // common_skill 105
  3189. 42, // job_skill 106
  3190. 42, // job_skill 107
  3191. 42, // job_skill 108
  3192. 42, // job_skill 109
  3193. 42, // job_skill 110
  3194. 42, // job_skill 111
  3195. 0, // common_skill 112
  3196. 0, // common_skill 113
  3197. 0, // common_skill 114
  3198. 0, // common_skill 115
  3199. 0, // common_skill 116
  3200. 0, // common_skill 117
  3201. 0, // common_skill 118
  3202. 0, // common_skill 119
  3203. 0, // common_skill 120
  3204. 0, // common_skill 121
  3205. 0, // common_skill 122
  3206. 0, // common_skill 123
  3207. 0, // common_skill 124
  3208. 0, // common_skill 125
  3209. 0, // common_skill 126
  3210. 0, // common_skill 127
  3211. 0, // common_skill 128
  3212. 0, // common_skill 129
  3213. 0, // common_skill 130
  3214. 0, // common_skill 131
  3215. 0, // common_skill 132
  3216. 0, // common_skill 133
  3217. 0, // common_skill 134
  3218. 0, // common_skill 135
  3219. 0, // common_skill 136
  3220. 0, // job_skill 137
  3221. 0, // job_skill 138
  3222. 0, // job_skill 139
  3223. 0, // job_skill 140
  3224. 0, // common_skill 141
  3225. 0, // common_skill 142
  3226. 0, // common_skill 143
  3227. 0, // common_skill 144
  3228. 0, // common_skill 145
  3229. 0, // common_skill 146
  3230. 0, // common_skill 147
  3231. 0, // common_skill 148
  3232. 0, // common_skill 149
  3233. 0, // common_skill 150
  3234. 0, // common_skill 151
  3235. 0, // job_skill 152
  3236. 0, // job_skill 153
  3237. 0, // job_skill 154
  3238. 0, // job_skill 155
  3239. 0, // job_skill 156
  3240. 0, // job_skill 157
  3241. #ifdef ENABLE_WOLFMAN_CHARACTER
  3242. 0, // empty(reserved) 158
  3243. 0, // empty(reserved) 159
  3244. 0, // empty(reserved) 160
  3245. 0, // empty(reserved) 161
  3246. 0, // empty(reserved) 162
  3247. 0, // empty(reserved) 163
  3248. 0, // empty(reserved) 164
  3249. 0, // empty(reserved) 165
  3250. 0, // empty(reserved) 166
  3251. 0, // empty(reserved) 167
  3252. 0, // empty(reserved) 168
  3253. 0, // empty(reserved) 169
  3254. 51, // job_skill(WOLFMAN SKILL) 170
  3255. 51, // job_skill(WOLFMAN SKILL) 171
  3256. 51, // job_skill(WOLFMAN SKILL) 172
  3257. 51, // job_skill(WOLFMAN SKILL) 173
  3258. 51, // job_skill(WOLFMAN SKILL) 174
  3259. 51, // job_skill(WOLFMAN SKILL) 175
  3260. #endif
  3261. }; // s_anSkill2JobGroup
  3263. const DWORD MOTION_MAX_NUM = 124;
  3264. #ifdef ENABLE_WOLFMAN_CHARACTER
  3265. const DWORD SKILL_LIST_MAX_COUNT = 6;
  3266. #else
  3267. const DWORD SKILL_LIST_MAX_COUNT = 5;
  3268. #endif
  3269. static DWORD s_anMotion2SkillVnumList[MOTION_MAX_NUM][SKILL_LIST_MAX_COUNT] =
  3270. {
  3271. // ½ºÅ³¼ö ¹«»ç½ºÅ³ID ÀÚ°´½ºÅ³ID ¼ö¶ó½ºÅ³ID ¹«´ç½ºÅ³ID ¼öÀÎÁ·(WOLFMAN) ½ºÅ³ID
  3272. { 0, 0, 0, 0, 0 }, // 0
  3274. // 1¹ø Á÷±º ±âº» ½ºÅ³
  3275. #ifdef ENABLE_WOLFMAN_CHARACTER
  3276. { 5, 1, 31, 61, 91, 170 }, // 1
  3277. { 5, 2, 32, 62, 92, 171 }, // 2
  3278. { 5, 3, 33, 63, 93, 172 }, // 3
  3279. { 5, 4, 34, 64, 94, 173 }, // 4
  3280. { 5, 5, 35, 65, 95, 174 }, // 5
  3281. { 5, 6, 36, 66, 96, 175 }, // 6
  3282. #else
  3283. { 4, 1, 31, 61, 91 }, // 1
  3284. { 4, 2, 32, 62, 92 }, // 2
  3285. { 4, 3, 33, 63, 93 }, // 3
  3286. { 4, 4, 34, 64, 94 }, // 4
  3287. { 4, 5, 35, 65, 95 }, // 5
  3288. { 4, 6, 36, 66, 96 }, // 6
  3289. #endif
  3290. { 0, 0, 0, 0, 0 }, // 7
  3291. { 0, 0, 0, 0, 0 }, // 8
  3292. // 1¹ø Á÷±º ±âº» ½ºÅ³ ³¡
  3294. // ¿©À¯ºĞ
  3295. { 0, 0, 0, 0, 0 }, // 9
  3296. { 0, 0, 0, 0, 0 }, // 10
  3297. { 0, 0, 0, 0, 0 }, // 11
  3298. { 0, 0, 0, 0, 0 }, // 12
  3299. { 0, 0, 0, 0, 0 }, // 13
  3300. { 0, 0, 0, 0, 0 }, // 14
  3301. { 0, 0, 0, 0, 0 }, // 15
  3302. // ¿©À¯ºĞ ³¡
  3304. // 2¹ø Á÷±º ±âº» ½ºÅ³
  3305. { 4, 16, 46, 76, 106 }, // 16
  3306. { 4, 17, 47, 77, 107 }, // 17
  3307. { 4, 18, 48, 78, 108 }, // 18
  3308. { 4, 19, 49, 79, 109 }, // 19
  3309. { 4, 20, 50, 80, 110 }, // 20
  3310. { 4, 21, 51, 81, 111 }, // 21
  3311. { 0, 0, 0, 0, 0 }, // 22
  3312. { 0, 0, 0, 0, 0 }, // 23
  3313. // 2¹ø Á÷±º ±âº» ½ºÅ³ ³¡
  3315. // ¿©À¯ºĞ
  3316. { 0, 0, 0, 0, 0 }, // 24
  3317. { 0, 0, 0, 0, 0 }, // 25
  3318. // ¿©À¯ºĞ ³¡
  3320. // 1¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³
  3321. #ifdef ENABLE_WOLFMAN_CHARACTER
  3322. { 5, 1, 31, 61, 91, 170 }, // 26
  3323. { 5, 2, 32, 62, 92, 171 }, // 27
  3324. { 5, 3, 33, 63, 93, 172 }, // 28
  3325. { 5, 4, 34, 64, 94, 173 }, // 29
  3326. { 5, 5, 35, 65, 95, 174 }, // 30
  3327. { 5, 6, 36, 66, 96, 175 }, // 31
  3328. #else
  3329. { 4, 1, 31, 61, 91 }, // 26
  3330. { 4, 2, 32, 62, 92 }, // 27
  3331. { 4, 3, 33, 63, 93 }, // 28
  3332. { 4, 4, 34, 64, 94 }, // 29
  3333. { 4, 5, 35, 65, 95 }, // 30
  3334. { 4, 6, 36, 66, 96 }, // 31
  3335. #endif
  3336. { 0, 0, 0, 0, 0 }, // 32
  3337. { 0, 0, 0, 0, 0 }, // 33
  3338. // 1¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³ ³¡
  3340. // ¿©À¯ºĞ
  3341. { 0, 0, 0, 0, 0 }, // 34
  3342. { 0, 0, 0, 0, 0 }, // 35
  3343. { 0, 0, 0, 0, 0 }, // 36
  3344. { 0, 0, 0, 0, 0 }, // 37
  3345. { 0, 0, 0, 0, 0 }, // 38
  3346. { 0, 0, 0, 0, 0 }, // 39
  3347. { 0, 0, 0, 0, 0 }, // 40
  3348. // ¿©À¯ºĞ ³¡
  3350. // 2¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³
  3351. { 4, 16, 46, 76, 106 }, // 41
  3352. { 4, 17, 47, 77, 107 }, // 42
  3353. { 4, 18, 48, 78, 108 }, // 43
  3354. { 4, 19, 49, 79, 109 }, // 44
  3355. { 4, 20, 50, 80, 110 }, // 45
  3356. { 4, 21, 51, 81, 111 }, // 46
  3357. { 0, 0, 0, 0, 0 }, // 47
  3358. { 0, 0, 0, 0, 0 }, // 48
  3359. // 2¹ø Á÷±º ¸¶½ºÅÍ ½ºÅ³ ³¡
  3361. // ¿©À¯ºĞ
  3362. { 0, 0, 0, 0, 0 }, // 49
  3363. { 0, 0, 0, 0, 0 }, // 50
  3364. // ¿©À¯ºĞ ³¡
  3366. // 1¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³
  3367. #ifdef ENABLE_WOLFMAN_CHARACTER
  3368. { 5, 1, 31, 61, 91, 170 }, // 51
  3369. { 5, 2, 32, 62, 92, 171 }, // 52
  3370. { 5, 3, 33, 63, 93, 172 }, // 53
  3371. { 5, 4, 34, 64, 94, 173 }, // 54
  3372. { 5, 5, 35, 65, 95, 174 }, // 55
  3373. { 5, 6, 36, 66, 96, 175 }, // 56
  3374. #else
  3375. { 4, 1, 31, 61, 91 }, // 51
  3376. { 4, 2, 32, 62, 92 }, // 52
  3377. { 4, 3, 33, 63, 93 }, // 53
  3378. { 4, 4, 34, 64, 94 }, // 54
  3379. { 4, 5, 35, 65, 95 }, // 55
  3380. { 4, 6, 36, 66, 96 }, // 56
  3381. #endif
  3382. { 0, 0, 0, 0, 0 }, // 57
  3383. { 0, 0, 0, 0, 0 }, // 58
  3384. // 1¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³ ³¡
  3386. // ¿©À¯ºĞ
  3387. { 0, 0, 0, 0, 0 }, // 59
  3388. { 0, 0, 0, 0, 0 }, // 60
  3389. { 0, 0, 0, 0, 0 }, // 61
  3390. { 0, 0, 0, 0, 0 }, // 62
  3391. { 0, 0, 0, 0, 0 }, // 63
  3392. { 0, 0, 0, 0, 0 }, // 64
  3393. { 0, 0, 0, 0, 0 }, // 65
  3394. // ¿©À¯ºĞ ³¡
  3396. // 2¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³
  3397. { 4, 16, 46, 76, 106 }, // 66
  3398. { 4, 17, 47, 77, 107 }, // 67
  3399. { 4, 18, 48, 78, 108 }, // 68
  3400. { 4, 19, 49, 79, 109 }, // 69
  3401. { 4, 20, 50, 80, 110 }, // 70
  3402. { 4, 21, 51, 81, 111 }, // 71
  3403. { 0, 0, 0, 0, 0 }, // 72
  3404. { 0, 0, 0, 0, 0 }, // 73
  3405. // 2¹ø Á÷±º ±×·£µå ¸¶½ºÅÍ ½ºÅ³ ³¡
  3407. //¿©À¯ºĞ
  3408. { 0, 0, 0, 0, 0 }, // 74
  3409. { 0, 0, 0, 0, 0 }, // 75
  3410. // ¿©À¯ºĞ ³¡
  3412. // 1¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³
  3413. #ifdef ENABLE_WOLFMAN_CHARACTER
  3414. { 5, 1, 31, 61, 91, 170 }, // 76
  3415. { 5, 2, 32, 62, 92, 171 }, // 77
  3416. { 5, 3, 33, 63, 93, 172 }, // 78
  3417. { 5, 4, 34, 64, 94, 173 }, // 79
  3418. { 5, 5, 35, 65, 95, 174 }, // 80
  3419. { 5, 6, 36, 66, 96, 175 }, // 81
  3420. #else
  3421. { 4, 1, 31, 61, 91 }, // 76
  3422. { 4, 2, 32, 62, 92 }, // 77
  3423. { 4, 3, 33, 63, 93 }, // 78
  3424. { 4, 4, 34, 64, 94 }, // 79
  3425. { 4, 5, 35, 65, 95 }, // 80
  3426. { 4, 6, 36, 66, 96 }, // 81
  3427. #endif
  3428. { 0, 0, 0, 0, 0 }, // 82
  3429. { 0, 0, 0, 0, 0 }, // 83
  3430. // 1¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³ ³¡
  3432. // ¿©À¯ºĞ
  3433. { 0, 0, 0, 0, 0 }, // 84
  3434. { 0, 0, 0, 0, 0 }, // 85
  3435. { 0, 0, 0, 0, 0 }, // 86
  3436. { 0, 0, 0, 0, 0 }, // 87
  3437. { 0, 0, 0, 0, 0 }, // 88
  3438. { 0, 0, 0, 0, 0 }, // 89
  3439. { 0, 0, 0, 0, 0 }, // 90
  3440. // ¿©À¯ºĞ ³¡
  3442. // 2¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³
  3443. { 4, 16, 46, 76, 106 }, // 91
  3444. { 4, 17, 47, 77, 107 }, // 92
  3445. { 4, 18, 48, 78, 108 }, // 93
  3446. { 4, 19, 49, 79, 109 }, // 94
  3447. { 4, 20, 50, 80, 110 }, // 95
  3448. { 4, 21, 51, 81, 111 }, // 96
  3449. { 0, 0, 0, 0, 0 }, // 97
  3450. { 0, 0, 0, 0, 0 }, // 98
  3451. // 2¹ø Á÷±º ÆÛÆåÆ® ¸¶½ºÅÍ ½ºÅ³ ³¡
  3453. // ¿©À¯ºĞ
  3454. { 0, 0, 0, 0, 0 }, // 99
  3455. { 0, 0, 0, 0, 0 }, // 100
  3456. // ¿©À¯ºĞ ³¡
  3458. // ±æµå ½ºÅ³
  3459. { 1, 152, 0, 0, 0}, // 101
  3460. { 1, 153, 0, 0, 0}, // 102
  3461. { 1, 154, 0, 0, 0}, // 103
  3462. { 1, 155, 0, 0, 0}, // 104
  3463. { 1, 156, 0, 0, 0}, // 105
  3464. { 1, 157, 0, 0, 0}, // 106
  3465. // ±æµå ½ºÅ³ ³¡
  3467. // ¿©À¯ºĞ
  3468. { 0, 0, 0, 0, 0}, // 107
  3469. { 0, 0, 0, 0, 0}, // 108
  3470. { 0, 0, 0, 0, 0}, // 109
  3471. { 0, 0, 0, 0, 0}, // 110
  3472. { 0, 0, 0, 0, 0}, // 111
  3473. { 0, 0, 0, 0, 0}, // 112
  3474. { 0, 0, 0, 0, 0}, // 113
  3475. { 0, 0, 0, 0, 0}, // 114
  3476. { 0, 0, 0, 0, 0}, // 115
  3477. { 0, 0, 0, 0, 0}, // 116
  3478. { 0, 0, 0, 0, 0}, // 117
  3479. { 0, 0, 0, 0, 0}, // 118
  3480. { 0, 0, 0, 0, 0}, // 119
  3481. { 0, 0, 0, 0, 0}, // 120
  3482. // ¿©À¯ºĞ ³¡
  3484. // ½Â¸¶ ½ºÅ³
  3485. { 2, 137, 140, 0, 0}, // 121
  3486. { 1, 138, 0, 0, 0}, // 122
  3487. { 1, 139, 0, 0, 0}, // 123
  3488. // ½Â¸¶ ½ºÅ³ ³¡
  3489. };
  3491. if (dwMotionIndex >= MOTION_MAX_NUM)
  3492. {
  3493. sys_err("OUT_OF_MOTION_VNUM: name=%s, motion=%d/%d", GetName(), dwMotionIndex, MOTION_MAX_NUM);
  3494. return false;
  3495. }
  3497. DWORD* skillVNums = s_anMotion2SkillVnumList[dwMotionIndex];
  3499. DWORD skillCount = *skillVNums++;
  3500. if (skillCount >= SKILL_LIST_MAX_COUNT)
  3501. {
  3502. sys_err("OUT_OF_SKILL_LIST: name=%s, count=%d/%d", GetName(), skillCount, SKILL_LIST_MAX_COUNT);
  3503. return false;
  3504. }
  3506. for (DWORD skillIndex = 0; skillIndex != skillCount; ++skillIndex)
  3507. {
  3508. if (skillIndex >= SKILL_MAX_NUM)
  3509. {
  3510. sys_err("OUT_OF_SKILL_VNUM: name=%s, skill=%d/%d", GetName(), skillIndex, SKILL_MAX_NUM);
  3511. return false;
  3512. }
  3514. DWORD eachSkillVNum = skillVNums[skillIndex];
  3515. if ( eachSkillVNum != 0 )
  3516. {
  3517. DWORD eachJobGroup = s_anSkill2JobGroup[eachSkillVNum];
  3519. if (0 == eachJobGroup || eachJobGroup == selfJobGroup)
  3520. {
  3521. // GUILDSKILL_BUG_FIX
  3522. DWORD eachSkillLevel = 0;
  3524. if (eachSkillVNum >= GUILD_SKILL_START && eachSkillVNum <= GUILD_SKILL_END)
  3525. {
  3526. if (GetGuild())
  3527. eachSkillLevel = GetGuild()->GetSkillLevel(eachSkillVNum);
  3528. else
  3529. eachSkillLevel = 0;
  3530. }
  3531. else
  3532. {
  3533. eachSkillLevel = GetSkillLevel(eachSkillVNum);
  3534. }
  3536. if (eachSkillLevel > 0)
  3537. {
  3538. return true;
  3539. }
  3540. // END_OF_GUILDSKILL_BUG_FIX
  3541. }
  3542. }
  3543. }
  3545. return false;
  3546. }
  3548. void CHARACTER::ClearSkill()
  3549. {
  3550. PointChange(POINT_SKILL, 4 + (GetLevel() - 5) - GetPoint(POINT_SKILL));
  3552. ResetSkill();
  3553. }
  3555. void CHARACTER::ClearSubSkill()
  3556. {
  3557. PointChange(POINT_SUB_SKILL, GetLevel() < 10 ? 0 : (GetLevel() - 9) - GetPoint(POINT_SUB_SKILL));
  3559. if (m_pSkillLevels == NULL)
  3560. {
  3561. sys_err("m_pSkillLevels nil (name: %s)", GetName());
  3562. return;
  3563. }
  3565. TPlayerSkill CleanSkill;
  3566. memset(&CleanSkill, 0, sizeof(TPlayerSkill));
  3568. size_t count = sizeof(s_adwSubSkillVnums) / sizeof(s_adwSubSkillVnums[0]);
  3570. for (size_t i = 0; i < count; ++i)
  3571. {
  3572. if (s_adwSubSkillVnums[i] >= SKILL_MAX_NUM)
  3573. continue;
  3575. m_pSkillLevels[s_adwSubSkillVnums[i]] = CleanSkill;
  3576. }
  3578. ComputePoints();
  3579. SkillLevelPacket();
  3580. }
  3582. bool CHARACTER::ResetOneSkill(DWORD dwVnum)
  3583. {
  3584. if (NULL == m_pSkillLevels)
  3585. {
  3586. sys_err("m_pSkillLevels nil (name %s, vnum %u)", GetName(), dwVnum);
  3587. return false;
  3588. }
  3590. if (dwVnum >= SKILL_MAX_NUM)
  3591. {
  3592. sys_err("vnum overflow (name %s, vnum %u)", GetName(), dwVnum);
  3593. return false;
  3594. }
  3596. BYTE level = m_pSkillLevels[dwVnum].bLevel;
  3598. m_pSkillLevels[dwVnum].bLevel = 0;
  3599. m_pSkillLevels[dwVnum].bMasterType = 0;
  3600. m_pSkillLevels[dwVnum].tNextRead = 0;
  3602. if (level > 17)
  3603. level = 17;
  3605. PointChange(POINT_SKILL, level);
  3607. LogManager::instance().CharLog(this, dwVnum, "ONE_SKILL_RESET_BY_SCROLL", "");
  3609. ComputePoints();
  3610. SkillLevelPacket();
  3612. return true;
  3613. }
  3615. int __MountAtkSkill(DWORD dwMountVnum, bool IsNew) // updated to 2014/12/10
  3616. {
  3617. if (!dwMountVnum)
  3618. return MOUNT_TYPE_NONE;
  3620. switch (dwMountVnum)
  3621. {
  3622. // ### YES SKILL
  3623. // @fixme116 begin
  3624. case 20107: // normal military horse (no guild)
  3625. case 20108: // normal military horse (guild member)
  3626. case 20109: // normal military horse (guild master)
  3627. if (IsNew)
  3628. return MOUNT_TYPE_NONE;
  3629. // @fixme116 end
  3630. // Classic
  3631. case 20110: // Classic Boar
  3632. case 20111: // Classic Wolf
  3633. case 20112: // Classic Tiger
  3634. case 20113: // Classic Lion
  3635. case 20114: // White Lion
  3636. // Special Lv2
  3637. case 20115: // Wild Battle Boar
  3638. case 20116: // Fight Wolf
  3639. case 20117: // Storm Tiger
  3640. case 20118: // Battle Lion (bugged)
  3641. case 20205: // Wild Battle Boar (alternative)
  3642. case 20206: // Fight Wolf (alternative)
  3643. case 20207: // Storm Tiger (alternative)
  3644. case 20208: // Battle Lion (bugged) (alternative)
  3645. // Royal Tigers
  3646. case 20120: // blue
  3647. case 20121: // dark red
  3648. case 20122: // gold
  3649. case 20123: // green
  3650. case 20124: // pied
  3651. case 20125: // white
  3652. // Royal mounts (Special Lv3)
  3653. case 20209: // Royal Boar
  3654. case 20210: // Royal Wolf
  3655. case 20211: // Royal Tiger
  3656. case 20212: // Royal Lion
  3657. //
  3658. case 20215: // Rudolph m Lv3 (yes skill, yes atk)
  3659. case 20218: // Rudolph f Lv3 (yes skill, yes atk)
  3660. case 20225: // Dyno Lv3 (yes skill, yes atk)
  3661. case 20230: // Turkey Lv3 (yes skill, yes atk)
  3662. return MOUNT_TYPE_MILITARY;
  3663. break;
  3664. // ### NO SKILL YES ATK
  3665. // @fixme116 begin
  3666. case 20104: // normal combat horse (no guild)
  3667. case 20105: // normal combat horse (guild member)
  3668. case 20106: // normal combat horse (guild master)
  3669. if (IsNew)
  3670. return MOUNT_TYPE_NONE;
  3671. // @fixme116 end
  3672. case 20119: // Black Horse (no skill, yes atk)
  3673. case 20214: // Rudolph m Lv2 (no skill, yes atk)
  3674. case 20217: // Rudolph f Lv2 (no skill, yes atk)
  3675. case 20219: // Equus Porphyreus (no skill, yes atk)
  3676. case 20220: // Comet (no skill, yes atk)
  3677. case 20221: // Polar Predator (no skill, yes atk)
  3678. case 20222: // Armoured Panda (no skill, yes atk)
  3679. case 20224: // Dyno Lv2 (no skill, yes atk)
  3680. case 20226: // Nightmare (no skill, yes atk)
  3681. case 20227: // Unicorn (no skill, yes atk)
  3682. case 20229: // Turkey Lv2 (no skill, yes atk)
  3683. case 20231: // Leopard (no skill, yes atk)
  3684. case 20232: // Black Panther (no skill, yes atk)
  3685. return MOUNT_TYPE_COMBAT;
  3686. break;
  3687. // ### NO SKILL NO ATK
  3688. // @fixme116 begin
  3689. case 20101: // normal beginner horse (no guild)
  3690. case 20102: // normal beginner horse (guild member)
  3691. case 20103: // normal beginner horse (guild master)
  3692. if (IsNew)
  3693. return MOUNT_TYPE_NONE;
  3694. // @fixme116 end
  3695. case 20213: // Rudolph m Lv1 (no skill, no atk)
  3696. case 20216: // Rudolph f Lv1 (no skill, no atk)
  3697. // Special Lv1
  3698. case 20201: // Boar Lv1 (no skill, no atk)
  3699. case 20202: // Wolf Lv1 (no skill, no atk)
  3700. case 20203: // Tiger Lv1 (no skill, no atk)
  3701. case 20204: // Lion Lv1 (no skill, no atk)
  3702. //
  3703. case 20223: // Dyno Lv1 (no skill, no atk)
  3704. case 20228: // Turkey Lv1 (no skill, no atk)
  3705. return MOUNT_TYPE_NORMAL;
  3706. break;
  3707. default:
  3708. return MOUNT_TYPE_NONE;
  3709. break;
  3710. }
  3711. }
  3713. const int SKILL_COUNT = 6;
  3714. static const DWORD SkillList[JOB_MAX_NUM][SKILL_GROUP_MAX_NUM][SKILL_COUNT] =
  3715. {
  3716. { { 1, 2, 3, 4, 5, 6 }, { 16, 17, 18, 19, 20, 21 } },
  3717. { { 31, 32, 33, 34, 35, 36 }, { 46, 47, 48, 49, 50, 51 } },
  3718. { { 61, 62, 63, 64, 65, 66 }, { 76, 77, 78, 79, 80, 81 } },
  3719. { { 91, 92, 93, 94, 95, 96 }, { 106,107,108,109,110,111 } },
  3720. #ifdef ENABLE_WOLFMAN_CHARACTER
  3721. { { 170,171,172,173,174,175 }, { 0, 0, 0, 0, 0, 0 } },
  3722. #endif
  3723. };
  3725. const DWORD GetRandomSkillVnum(BYTE bJob = JOB_MAX_NUM);
  3726. const DWORD GetRandomSkillVnum(BYTE bJob)
  3727. {
  3728. // the chosen skill
  3729. DWORD dwSkillVnum = 0;
  3730. do
  3731. {
  3732. // tmp stuff
  3733. DWORD tmpJob = (bJob != JOB_MAX_NUM)?MINMAX(0, bJob, JOB_MAX_NUM-1):number(0, JOB_MAX_NUM-1);
  3734. DWORD tmpSkillGroup = number(0, SKILL_GROUP_MAX_NUM-1);
  3735. DWORD tmpSkillCount = number(0, SKILL_COUNT-1);
  3736. // set skill
  3737. dwSkillVnum = SkillList[tmpJob][tmpSkillGroup][tmpSkillCount];
  3739. if (dwSkillVnum != 0 && NULL != CSkillManager::instance().Get(dwSkillVnum))
  3740. break;
  3741. } while (true);
  3742. return dwSkillVnum;
  3743. }
  3745. bool CHARACTER::CanUseSkill(DWORD dwSkillVnum) const
  3746. {
  3747. if (0 == dwSkillVnum) return false;
  3749. if (0 < GetSkillGroup())
  3750. {
  3751. const DWORD* pSkill = SkillList[ GetJob() ][ GetSkillGroup()-1 ];
  3753. for (int i=0 ; i < SKILL_COUNT ; ++i)
  3754. {
  3755. if (pSkill[i] == dwSkillVnum) return true;
  3756. }
  3757. }
  3759. //if (true == IsHorseRiding())
  3761. if (true == IsRiding())
  3762. {
  3763. //¸¶¿îÆ® Å»°ÍÁß °í±Ş¸»¸¸ ½ºÅ³ »ç¿ë°¡´É
  3764. #ifdef ENABLE_MOUNTSKILL_CHECK
  3765. int iIsMount = __MountAtkSkill(GetMountVnum(), false);
  3766. if (iIsMount!=MOUNT_TYPE_MILITARY)
  3767. {
  3768. if (test_server)
  3769. sys_log(0, "CanUseSkill: Mount can't skill. vnum(%u) type(%d)", GetMountVnum(), iIsMount);
  3770. return false;
  3771. }
  3772. #endif
  3773. switch(dwSkillVnum)
  3774. {
  3775. case SKILL_HORSE_WILDATTACK:
  3776. case SKILL_HORSE_CHARGE:
  3777. case SKILL_HORSE_ESCAPE:
  3778. case SKILL_HORSE_WILDATTACK_RANGE:
  3779. return true;
  3780. }
  3781. }
  3783. switch( dwSkillVnum )
  3784. {
  3785. case 121: case 122: case 124: case 126: case 127: case 128: case 129: case 130:
  3786. case 131:
  3787. case 151: case 152: case 153: case 154: case 155: case 156: case 157: case 158: case 159:
  3788. return true;
  3789. }
  3791. return false;
  3792. }
  3794. bool CHARACTER::CheckSkillHitCount(const BYTE SkillID, const VID TargetVID)
  3795. {
  3796. std::map<int, TSkillUseInfo>::iterator iter = m_SkillUseInfo.find(SkillID);
  3798. if (iter == m_SkillUseInfo.end())
  3799. {
  3800. sys_log(0, "SkillHack: Skill(%u) is not in container", SkillID);
  3801. return false;
  3802. }
  3804. TSkillUseInfo& rSkillUseInfo = iter->second;
  3806. if (false == rSkillUseInfo.bUsed)
  3807. {
  3808. sys_log(0, "SkillHack: not used skill(%u)", SkillID);
  3809. return false;
  3810. }
  3812. switch (SkillID)
  3813. {
  3814. case SKILL_YONGKWON:
  3815. case SKILL_HWAYEOMPOK:
  3816. case SKILL_DAEJINGAK:
  3817. case SKILL_PAERYONG:
  3818. sys_log(0, "SkillHack: cannot use attack packet for skill(%u)", SkillID);
  3819. return false;
  3820. }
  3822. boost::unordered_map<VID, size_t>::iterator iterTargetMap = rSkillUseInfo.TargetVIDMap.find(TargetVID);
  3824. if (rSkillUseInfo.TargetVIDMap.end() != iterTargetMap)
  3825. {
  3826. size_t MaxAttackCountPerTarget = 1;
  3828. switch (SkillID)
  3829. {
  3830. case SKILL_SAMYEON:
  3831. case SKILL_CHARYUN:
  3832. #ifdef ENABLE_WOLFMAN_CHARACTER
  3833. case SKILL_PASWAE:
  3834. #endif
  3835. MaxAttackCountPerTarget = 3;
  3836. break;
  3838. case SKILL_HORSE_WILDATTACK_RANGE:
  3839. MaxAttackCountPerTarget = 5;
  3840. break;
  3842. case SKILL_YEONSA:
  3843. MaxAttackCountPerTarget = 7;
  3844. break;
  3846. case SKILL_HORSE_ESCAPE:
  3847. MaxAttackCountPerTarget = 10;
  3848. break;
  3849. }
  3851. if (iterTargetMap->second >= MaxAttackCountPerTarget)
  3852. {
  3853. sys_log(0, "SkillHack: Too Many Hit count from SkillID(%u) count(%u)", SkillID, iterTargetMap->second);
  3854. return false;
  3855. }
  3857. iterTargetMap->second++;
  3858. }
  3859. else
  3860. {
  3861. rSkillUseInfo.TargetVIDMap.insert( std::make_pair(TargetVID, 1) );
  3862. }
  3864. return true;
  3865. }