API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 23rd, 2017
81
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 38.27 KB | None | 0 0
raw download clone embed print report
  1. const NTA_DAMAGE_NONE = 0;
  2. const NTA_DAMAGE_PHYSICAL = 1;
  3. const NTA_DAMAGE_MAGIC = 2;
  4. const NTA_DAMAGE_FIRE = 3;
  5. const NTA_DAMAGE_LIGHTNING = 4;
  6. const NTA_DAMAGE_COLD = 5;
  7. const NTA_DAMAGE_POISON = 6;
  8. var _NTA_SkillDamage=[];
  9. var _NTA_SkillDelay =[];
  10. var _NTA_SkillHand =[];
  11. var ignoreKorpse =[];
  12. const DEAD_MODE = (1<<29)|(1<<12);
  13. function NTA_KillBoss(classid)
  14. {
  15. var _target;
  16.  
  17. if(NTConfig_AttackBoss < 1)
  18. return false;
  19.  
  20. _target = NTC_FindMonster(classid);
  21.  
  22. if(_target)
  23. {
  24. if(NTConfig_AttackFirst > 0 && NTA_GetResistance(_target, NTA_GetDamageType(NTConfig_AttackFirst)) < 100)
  25. {
  26. if(NTC_IsLeftSkill(NTConfig_AttackFirst))
  27. NTC_DoCast(NTConfig_AttackFirst, 2, _target);
  28. else
  29. NTC_DoCast(NTConfig_AttackFirst, NTC_HAND_RIGHT, _target);
  30. }
  31.  
  32. return NTA_Attack(_target, true, 100);
  33. }
  34.  
  35. return false;
  36. }
  37.  
  38. function NTA_ClearPosition(range, spectype)
  39. {
  40. var _orgx, _orgy;
  41. var _target;
  42. var _killnum = 0;
  43. var _units = 0;
  44.  
  45. //if(NTConfig_AttackOthers < 1)
  46. // return false;
  47.  
  48. if(arguments.length < 1)
  49. range = 20;
  50.  
  51. if(arguments.length < 2)
  52. spectype = 0;
  53.  
  54. _orgx = me.x;
  55. _orgy = me.y;
  56.  
  57. _target = NTC_GetUnit(NTC_UNIT_MONSTER);
  58.  
  59. _units = 0;
  60.  
  61. if(_target)
  62. {
  63. // print("Start Unit Loop.");
  64.  
  65. do
  66. {
  67. if(NTA_IsValidTarget(_target) && (spectype == 0 || (_target.spectype & spectype)) && getDistance(_orgx, _orgy, _target.x, _target.y) < range)
  68. {
  69. // print("Step 1");
  70.  
  71. _target = copyUnit(_target);
  72.  
  73. // print("Step 2");
  74.  
  75.  
  76.  
  77.  
  78. if(_killnum == 0 && _target.hp > 0)
  79. {
  80. // print("Step 3");
  81.  
  82. if(NTConfig_AttackFirst > 0 && NTA_GetResistance(_target, NTA_GetDamageType(NTConfig_AttackFirst)) < 100 && checkCollision(me, _target, 3) == 0)
  83. {
  84. // print("Step 4");
  85.  
  86. if(NTC_IsLeftSkill(NTConfig_AttackFirst))
  87. {
  88. // print("Step 5A");
  89. NTC_DoCast(NTConfig_AttackFirst, 2, _target);
  90. // print("Step 6A");
  91. }
  92. else
  93. {
  94. // print("Step 5B");
  95. NTC_DoCast(NTConfig_AttackFirst, NTC_HAND_RIGHT, _target);
  96. // print("Step 6B");
  97. }
  98.  
  99. // PickIt (FastSnag)
  100. NTSI_FastSnag();
  101. // print("Step 7");
  102. }
  103. }
  104.  
  105. // print("Step 8");
  106. if(NTA_Attack(_target, false, 20))
  107. {
  108. // print("Step 9");
  109. _killnum++;
  110. }
  111.  
  112. // print("Step 10");
  113. }
  114.  
  115. // print("Unit : " + _units++);
  116. }
  117. while(_target.getNext() && _target);
  118.  
  119. // print("End Unit Loop.");
  120. // print("-------------------------------------");
  121. }
  122. if (me.classid == NTC_CHAR_CLASS_NECROMANCER){ //build army
  123. if (XP_useSkel) {
  124. var success = XP_CheckRevives(70,363);
  125. }
  126. // Check Skeleton Mages
  127. if (XP_useSkelMage && success) {
  128. success = XP_CheckRevives(80,364);
  129. }
  130. // Check Revives
  131. if (XP_useRevive && success) {
  132. success = XP_CheckRevives(95);
  133. }
  134. }
  135. if(me.classid == NTC_CHAR_CLASS_PALADIN)
  136. {
  137. if(NTConfig_UseRedemption && _killnum > 1 && NTC_PutSkill(124, NTC_HAND_RIGHT))
  138. {
  139. NTC_PingDelay(750);
  140. }
  141. }
  142.  
  143. return (_killnum > 0);
  144. }
  145.  
  146. function isRoomReachable(room){
  147. var col = room.getCollision();
  148. //print("x size"+ room.xsize+" y size"+ room.ysize);
  149. /*
  150. for (var x =1; x < room.xsize; x++){
  151. if (col[0][x] ==0)
  152. return [room.x*5+x,room.y*5]
  153. if (col[room.ysize-1][x] ==0)
  154. return [room.x*5+x,room.y*5+room.ysize]
  155. }
  156. for (var y =1; y < room.ysize; y++){
  157. if (col[y][0] ==0)
  158. return [room.x*5,room.y*5+y]
  159. if (col[y][room.xsize-1] ==0)
  160. return [room.x*5+room.xsize,room.y*5+y]
  161. }
  162. */
  163. var size = (room.ysize > room.xsize ? room.ysize : room.xsize)
  164. for (var y =1; y < room.xsize -1; y++){
  165. for (var x =1; x < room.ysize-1; x++){
  166. if (col[x][y] == 0)
  167. //if(col[x-1][y] == && col[x-1][y-1] == 0 && col[x+1][y] == 0 && col[x+1][y+1] == 0 )
  168. return [room.x*5+y,room.y*5+x,size]; // this is probly wrong fixed x/y swap
  169.  
  170. }
  171. }
  172. // dumpRoom(room)
  173. return false;
  174. }
  175. function dumpRoom(room){
  176. var col = room.getCollision();
  177. var output ="";
  178. sendCopyData(null, "OOG", 0,room.x+" "+room.y);
  179. for (var x =0; x < room.xsize ; x++){
  180. output=" ";
  181.  
  182. for (var y =0; y < room.ysize; y++){
  183. output= output + col[x][y];
  184. }
  185. sendCopyData(null, "OOG", 0,output+" ");
  186. }
  187. return false;
  188. }
  189. function NTA_ClearRooms(AttackRoutine,minX,minY,maxX,maxY)
  190. {
  191.  
  192. if (minX > maxX){
  193. var tempx = maxX;
  194. maxX = minX;
  195. minX = tempx;
  196. }
  197. if (minX > maxX){
  198. var tempy = maxY;
  199. maxY = minY;
  200. minY = tempy;
  201. }
  202. var _room;
  203. var _rooms;
  204. var rx,ry,path,reachable;
  205. _room = getRoom();
  206.  
  207. if(!_room)
  208. return false;
  209.  
  210. _rooms = new Array();
  211. var size = (_room.xsize > _room.ysize) ? _room.xsize : _room.ysize ;
  212. do
  213. {
  214. rx = parseInt(_room.x*5 + _room.xsize/2);
  215. ry = parseInt(_room.y*5 + _room.ysize/2)
  216. //path= getPath(me.area, me.x, me.y, rx, ry,false);
  217.  
  218. reachable =isRoomReachable(_room);
  219. if (reachable){
  220. //if (reachable[0]==7741)
  221. // dumpRoom(_room);
  222. //
  223. if (maxX && maxY){
  224. if (rx <maxX && ry <maxY && rx > minX && ry > minY){
  225. _rooms.push([reachable[0],reachable[1]])//([parseInt(_room.x*5 + _room.xsize/2), parseInt(_room.y*5 + _room.ysize/2)]);
  226. }
  227. }else{
  228. _rooms.push([reachable[0],reachable[1]])//[parseInt(_room.x*5 + _room.xsize/2), parseInt(_room.y*5 + _room.ysize/2)]);
  229. }
  230. }
  231.  
  232. } while(_room.getNext());
  233.  
  234. while(_rooms.length > 0)
  235. {
  236. _rooms.sort(NTA_SortRoomInt);
  237. _room = _rooms.shift();
  238. // print(_rooms.toSource());
  239. NTM_MoveTo(_room[0], _room[1]);
  240. if(typeof(AttackRoutine) == 'function'){
  241. if(!AttackRoutine(size))
  242. return false;
  243. }else{
  244. NTA_ClearPosition(size); //clear as big as the room are some are up to 60
  245. NTSI_PickItems();
  246. NTP_UpdatePrecast();
  247. }
  248. }
  249. return true;
  250. }
  251.  
  252.  
  253.  
  254.  
  255. function NTA_IsValidTarget(monster, simple)
  256. {
  257. if(!monster || monster.type != NTC_UNIT_MONSTER)
  258. return false;
  259.  
  260. if(monster.mode == 0 || monster.mode == 12 || monster.hp <= 0)
  261. return false;
  262.  
  263. if(arguments.length < 2)
  264. simple = false;
  265.  
  266. if(!simple)
  267. {
  268. if(!monster.name)
  269. return false;
  270.  
  271. switch(monster.name.toLowerCase())
  272. {
  273. case "dummy":
  274. case "an evil force":
  275. return false;
  276. }
  277.  
  278. switch(monster.classid)
  279. {
  280. case 271: // Merc
  281. case 338:
  282. case 359:
  283. case 561:
  284.  
  285. case 356: // Decoy
  286. case 357: // Valkyrie
  287. case 418: // Shadow Warrior
  288. case 419: // Shadow Master
  289.  
  290. case 363: // Necro Skeleton
  291. case 364: // Necro Mage
  292.  
  293. case 366: // Compelling Orb
  294. case 406: // Izual's Spirit
  295.  
  296. case 266: // Act1: Flavie (Navi) -> Between BloodMoor & ColdPlains
  297. case 408: // Act4: Hadriel (Malachai) -> Entrance of River of Flames
  298.  
  299. case 516: // Act5: Impact point for Catapults (Invisible) -> Frigid Highlands
  300. case 517: // Act5: Impact point for Catapults (Invisible)
  301. case 518: // Act5: Impact point for Catapults (Invisible) -> Bloodyfoot Hill
  302. case 519: // Act5: Impact point for Catapults (Invisible)
  303. case 522: // Act5: Combatant Barbarian
  304. case 523: // Act5: Combatant Barbarian
  305.  
  306. case 543: // Baal on stairs outside Worldstone Chamber
  307. case 545: // Baal taunts
  308. return false;
  309. }
  310.  
  311. if(monster.classid >= 289 && monster.classid <= 292) // Necro's Golem
  312. return false;
  313.  
  314. if((monster.classid >= 326 && monster.classid <= 330) || (monster.classid >= 410 && monster.classid <= 417)) // Traps
  315. return false;
  316.  
  317. if(monster.classid >= 351 && monster.classid <= 353) // Hydra
  318. return false;
  319.  
  320. if(monster.classid >= 420 && monster.classid <= 432) // Druid's friend
  321. return false;
  322. }
  323.  
  324. if(((monster.classid >= 110 && monster.classid <= 113) || monster.classid == 608) && monster.mode == 8)
  325. return false;
  326.  
  327. if(monster.classid == 68 && monster.mode == 14)
  328. return false;
  329.  
  330. if((monster.classid == 258 || monster.classid == 261) && monster.mode == 14)
  331. return false;
  332.  
  333. if(monster.getStat(172) == 2 || monster.getState(105) == 0)
  334. return false;
  335.  
  336. if(monster.getState(53) || monster.getState(96)) // Conversion, Revive
  337. return false;
  338.  
  339. //if(getBaseStat(1, monster.classid, 23))
  340. // return false;
  341.  
  342. return true;
  343. }
  344.  
  345. // cwkim - Check later
  346. function NTA_GetDamageType(skillid)
  347. {
  348. switch(skillid)
  349. {
  350. case 74: // Corpse Explosion
  351. case 106: // Zeal
  352. case 107: // Charge
  353. case 151: // Whirlwind
  354. return NTA_DAMAGE_PHYSICAL;
  355.  
  356. case 112: // Blessed Hammer
  357. return NTA_DAMAGE_MAGIC;
  358.  
  359. case 47: // Fire Ball
  360. case 56: // Meteor
  361. return NTA_DAMAGE_FIRE;
  362.  
  363. case 48: // Nova
  364. case 49: // Lightning
  365. case 53: // Chain Lightning
  366. return NTA_DAMAGE_LIGHTNING;
  367.  
  368. case 59: // Blizzard
  369. case 64: // Frozen Orb
  370. return NTA_DAMAGE_COLD;
  371.  
  372. case 92: // Poison Nova
  373. return NTA_DAMAGE_POISON;
  374. }
  375.  
  376. var _etype;
  377.  
  378. if(skillid == 74)
  379. return NTA_DAMAGE_PHYSICAL;
  380. if(skillid == 101)
  381. return NTA_DAMAGE_NONE;
  382. _etype = getBaseStat(3, parseInt(skillid, 10), 211);
  383.  
  384. switch(_etype)
  385. {
  386. case 0: return NTA_DAMAGE_PHYSICAL;
  387. case 1: return NTA_DAMAGE_FIRE;
  388. case 2: return NTA_DAMAGE_LIGHTNING;
  389. case 3: return NTA_DAMAGE_MAGIC;
  390. case 4: return NTA_DAMAGE_COLD;
  391. case 5: return NTA_DAMAGE_POISON;
  392. }
  393.  
  394. return NTA_DAMAGE_NONE;
  395. }
  396.  
  397. function NTA_GetResistance(enemy, type)
  398. {
  399. if(!enemy)
  400. return false;
  401.  
  402. if(arguments.length == 2)
  403. {
  404. switch(type)
  405. {
  406. case NTA_DAMAGE_PHYSICAL:
  407. return enemy.getStat(36);
  408.  
  409. case NTA_DAMAGE_MAGIC:
  410. return enemy.getStat(37);
  411.  
  412. case NTA_DAMAGE_FIRE:
  413. return enemy.getStat(39);
  414.  
  415. case NTA_DAMAGE_LIGHTNING:
  416. return enemy.getStat(41);
  417.  
  418. case NTA_DAMAGE_COLD:
  419. return enemy.getStat(43);
  420.  
  421. case NTA_DAMAGE_POISON:
  422. return enemy.getStat(45);
  423. }
  424. }
  425.  
  426. return 0;
  427. }
  428.  
  429. function NTA_Attack(target, boss, maxattacks)
  430. {
  431. switch(me.classid)
  432. {
  433. case NTC_CHAR_CLASS_AMAZON:
  434. return NTA_AmazonAttackInt(target, boss, maxattacks);
  435.  
  436. case NTC_CHAR_CLASS_SORCERESS:
  437. return NTA_SorceressAttackInt(target, boss, maxattacks);
  438.  
  439. case NTC_CHAR_CLASS_NECROMANCER:
  440. return NTA_NecromancerAttackInt(target, boss, maxattacks);
  441.  
  442. case NTC_CHAR_CLASS_PALADIN:
  443. return NTA_PaladinAttackInt(target, boss, maxattacks);
  444.  
  445. case NTC_CHAR_CLASS_BARBARIAN:
  446. return NTA_BarbarianAttackInt(target, boss, maxattacks);
  447.  
  448. case NTC_CHAR_CLASS_DRUID:
  449. return NTA_DruidAttackInt(target, boss, maxattacks);
  450.  
  451. case NTC_CHAR_CLASS_ASSASSIN:
  452. return NTA_AssassinAttackInt(target, boss, maxattacks);
  453. }
  454.  
  455. return false;
  456. }
  457.  
  458. // Internal function
  459. function NTA_AmazonAttackInt(target,boss,maxattacks) {
  460. var attack=0,prehp=target.hp,hits=0,misses=0;
  461. while(attack++<maxattacks&&target.hp>0) {
  462. if(boss) {
  463. if(attack==1||attack%3==0&&miss||getDistance(me,target)>6)
  464. NTM_MoveTo(target.x+1,target.y+2);
  465. if(target.hp>0) {
  466. if(me.getSkill(2)!=24)
  467. me.setSkill(24,0);
  468. clickMap(3,0,target);
  469. delay(100);
  470. clickMap(5);
  471. }
  472. }else {
  473. if(attack==1||getDistance(me,target)>35)
  474. NTA_MoveCloseInt(target,20);
  475. if(attack%6==0&&miss&&getDistance(me,target)>3)
  476. NTA_MoveCloseInt(target,getDistance(me,target)-6);
  477. if(target.hp>0) {
  478. if(getDistance(me,target)>3)
  479. me.setSkill(2,0);
  480. me.setSkill(24,0);
  481. clickMap(3,1,target);
  482. delay(100);
  483. clickMap(5);
  484. }
  485. }var hit=target.hp<prehp,miss=target.hp>=prehp; if(hit)hits++; if(miss)misses++;
  486. }NTSI_FastSnag();
  487. if(NTConfig_CheckSafe)
  488. NTTMGR_CheckSafe(1);
  489. return true;
  490. }
  491.  
  492.  
  493. function NTA_SorceressAttackInt(target, boss, maxattacks)
  494. {
  495. var _primaryindex = boss ? 1 : 2;
  496. var _maxattacks = 0;
  497. var _range;
  498. var _prehp;
  499. var _nohit;
  500. var castfirst;
  501. var checkprimaryres;
  502. var checksecondaryres;
  503. var _merc = me.getMerc();
  504. var usemerc;
  505.  
  506. if(NTConfig_AttackSkill[1]==48||NTConfig_AttackSkill[2]==48)
  507. _range = 10;
  508. else
  509. _range = 20;
  510.  
  511. if(NTConfig_AttackSkill[3]==48||NTConfig_AttackSkill[5]==48)
  512. _range = 10;
  513. else
  514. _range = 20;
  515.  
  516. if(NTConfig_CastStatic < 100)
  517. {
  518. var _staticlevel = NTC_CheckSkill(42);
  519.  
  520. if(_staticlevel > 0 && target.getStat(41) < 100 && (boss || checkCollision(me, target, 3) == 0))
  521. {
  522. var _cast = 0;
  523. var _staticrange = Math.floor(1.0 + 0.668*_staticlevel);
  524. if(parseInt(target.hp*100/128) > NTConfig_CastStatic)
  525. NTA_MoveCloseInt(target, 20);
  526. while(_cast++ < 10 && parseInt(target.hp*100/128) > NTConfig_CastStatic)
  527. {
  528. if(me.setSkill(42, 0))
  529. if(clickMap(3, 1, target))if(delay(100))if(clickMap(5))delay(100);
  530. }
  531. }
  532. }
  533.  
  534. if(NTConfig_AttackSkill[0] > 0) castfirst = true;
  535. if(NTA_GetResistance(target,_NTA_SkillDamage[_primaryindex])<100) checkprimaryres = true;
  536. if(NTConfig_AttackSkill[4] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[4]) < 100) checksecondaryres = true;
  537. if(NTConfig_UseMerc && _merc) usemerc = true;
  538.  
  539. _prehp = target.hp;
  540.  
  541. while(_maxattacks++ < maxattacks && NTA_IsValidTarget(target, true))
  542. {
  543. NTSI_FastSnag();
  544. if(_maxattacks==1)
  545. {
  546. if(target.classid==243||target.classid==544)
  547. NTM_MoveTo(target.x+2,target.y+5);
  548. else
  549. NTA_MoveCloseInt(target, _range);
  550. if(castfirst&&me.setSkill(NTConfig_AttackSkill[0], 0))
  551. if(clickMap(3, 1, target))if(delay(100))if(clickMap(5))delay(100);
  552. }
  553. if(checkprimaryres)
  554. {
  555. if((target.classid==243||target.classid==544)&&getDistance(me,target)>6)
  556. NTM_MoveTo(target.x+2,target.y+5);
  557. else if(_maxattacks%3==0&&_nohit&&_maxattacks<13||getDistance(me,target)>_range)
  558. NTA_MoveCloseInt(target, _range);
  559. if(!(target.classid==243||target.classid==544)&&_maxattacks%3==1&&getDistance(me,target)<3)
  560. NTM_MoveTo(target.x+2,me.y+2);
  561. if(!boss&&_maxattacks%3==0&&_maxattacks>13)
  562. NTA_MoveCloseInt(target,1);
  563. NTA_DoCastInt(_primaryindex, target);
  564. }
  565. else if(checksecondaryres)
  566. {
  567. if(_maxattacks == 1 || _maxattacks % 3 == 0 && _nohit || getDistance(me, target) > _range)
  568. NTA_MoveCloseInt(target, _range);
  569. if (getDistance(me,target)<3)
  570. NTM_MoveTo(target.x+2,target.y+2);
  571. if(_maxattacks%3==1&&_maxattacks>13)
  572. NTA_MoveCloseInt(target,3);
  573. NTA_DoCastInt(4, target);
  574. }
  575. else if(usemerc)
  576. {
  577. if (getDistance(me,target)<3)
  578. NTM_MoveTo(target.x+2,me.y+2);
  579. if (getDistance(me, target)>6)
  580. if(NTA_MoveCloseInt(target,3))delay(1000);
  581. me.setSkill(NTConfig_AttackSkill[2], 0);
  582. if(clickMap(3,1,target))if(delay(100))if(clickMap(5))delay(100);
  583. }
  584. if(target.hp >= _prehp) _nohit = true; else _nohit = false;
  585. }
  586. NTSI_FastSnag();
  587. if(NTConfig_CheckSafe)
  588. NTTMGR_CheckSafe(1);
  589. return true;
  590. }
  591.  
  592. function getCurseState(curse){
  593. if (curse == 66) // Amplify Damage
  594. return 9;
  595. if (curse == 76) //iron maden
  596. return 55;
  597. if (curse == 82) //life tap
  598. return 58;
  599. if (curse == 87)//Decrepify
  600. return 60;
  601. if (curse == 91) //lower resist
  602. return 61;
  603. return 1;
  604. }
  605.  
  606. function getIntoLOS(target){
  607. //for (var j = 0 ; j <15 ; j++){
  608. // sendCopyData(null, "OOG", 0,"col "+j +" " +checkCollision(me, target,j)+ "x: "+target.x);
  609. //}
  610.  
  611. if(checkCollision(me, target,10)){
  612. //print("moving closer collision")
  613. NTA_MoveCloseInt(target, Math.round(getDistance(me, target)/2));
  614. }
  615. if(checkCollision(me, target,2)){
  616. //print("moving closer collision")
  617. NTA_MoveCloseInt(target, Math.round(getDistance(me, target)/2));
  618. }
  619. if(checkCollision(me, target,1)){
  620. //print("moving closer collision")
  621. NTA_MoveCloseInt(target, Math.round(getDistance(me, target)/2));
  622. }
  623. }
  624. function NTA_NecromancerAttackInt(target, boss, maxattacks)
  625. {
  626. var _maxattacks = 0
  627. //move these to global
  628. var armySize = 0;
  629. var success;
  630.  
  631.  
  632. while(_maxattacks++ < maxattacks && NTA_IsValidTarget(target, true) && target.hp > 0){
  633. armySize =me.getMinionCount(4)+me.getMinionCount(5)+me.getMinionCount(6);
  634. if (armySize > XP_BuildArmyThresh){
  635. if(target && (!target.getState(getCurseState(XP_Curse)) ) && target.classid != 371)
  636. NTC_DoCast(XP_Curse,0,target);
  637. }else{
  638. if(target && (!target.getState(getCurseState(XP_BuildArmyCurse)) ) && target.classid != 371)
  639. NTC_DoCast(XP_BuildArmyCurse,0,target);
  640. }
  641.  
  642.  
  643.  
  644. getIntoLOS(target);
  645. if (boss)
  646. NTC_DoCast(NTConfig_AttackBoss,0,target);
  647. else
  648. NTC_DoCast(NTConfig_AttackOthers,0,target);
  649.  
  650. //if (armySize > XP_BuildArmyThresh && getDistance(me.x,me.y,target.x,target.y)>5){
  651. //sendCopyData(null, "OOG", 0,"going closer");
  652. //NTM_MoveTo(target.x+1, target.y, 0) //stay on mob if we got army going
  653. //clickMap(0,0,me.x,me.y+1);
  654. //}
  655. if (XP_CorpseExplosion) {
  656. XP_UseNecroCE(target);
  657. }
  658. if (XP_useSkel) {
  659. var success = XP_CheckRevives(70,363);
  660. }
  661. // Check Skeleton Mages
  662. if (XP_useSkelMage && success) {
  663. success = XP_CheckRevives(80,364);
  664. }
  665. // Check Revives
  666. if (XP_useRevive && success) {
  667. success = XP_CheckRevives(95);
  668. }
  669. }
  670. if(NTConfig_CheckSafe)
  671. {
  672. if(!NTTMGR_CheckSafe(1))
  673. return false;
  674. }
  675.  
  676. NTSI_FastSnag();
  677. return true;
  678. }
  679. function XP_CheckRevives(reviveSkill,reviveID) {
  680. if (reviveSkill != 70 && reviveSkill != 80 && reviveSkill != 95){
  681. //DC_DPrint("XP_CheckRevives() -> Invalid skill passed!");
  682. return false;
  683. }
  684. var success = false;
  685. var haveRevive = 0;
  686. var maxRevives = XP_MaxRevives(reviveSkill);
  687. var needMana = 0;
  688. var skeltype = 0;
  689. var XP_ToRevive = 3;
  690. var i = 0;
  691. // get the right skeltype id (4 = skeleton, 5 = skeletonmage, 6 = revive)
  692. switch(reviveSkill){
  693. case 70:
  694. needMana = 5 + NTC_CheckSkill(reviveSkill);
  695. skeltype = 4;
  696. break;
  697. case 80:
  698. needMana = 7 + NTC_CheckSkill(reviveSkill);
  699. skeltype = 5;
  700. break;
  701. case 95:
  702. needMana = 45;
  703. skeltype = 6;
  704. break;
  705. }
  706. // Count my revives
  707. haveRevive = me.getMinionCount(skeltype);//0;
  708. success = (haveRevive >= maxRevives || me.mp <= needMana);
  709. //XP_ToRevive controls how many corpses to proccess per function call
  710. while (haveRevive < maxRevives && me.mp > needMana && i++ < XP_ToRevive) {
  711. var korpse = getBodyTarget(25);
  712. if (reviveSkill == 95) {
  713. if (korpse && ((korpse.spectype & 0x07) == 0) && korpse.classid != 571
  714. && korpse.classid != 572 && korpse.classid != 573
  715. && korpse.classid != 312 && korpse.classid != 702
  716. && getBaseStat(6, korpse.classid, 8) && getBaseStat(6, korpse.classid, 9)) {
  717. //DC_DPrint("Reviving " + korpse.name + " from range " + DA_GetRange(korpse));
  718. // print("Reviving " + korpse.name + " from range " + DA_GetRange(korpse));
  719. getIntoLOS(korpse);
  720. //print("Raising " + (reviveSkill == 70 ? "Skel": "Mage") + " from " + korpse.name + " from range " + getDistance(me,korpse));
  721. NTC_DoCast(reviveSkill,0,korpse.x,korpse.y,1); // casting revive fails some times so im just going to try once
  722. //delay(500);
  723. success = true;
  724. }
  725. else if (!korpse){
  726. break;
  727. }
  728. }
  729. else { // Skel or SkelMage
  730. if(korpse){
  731. var iLoop = 0;
  732. //DC_DPrint("Raising " + (reviveSkill == 70 ? "Skel": "Mage") + " from " + korpse.name + " from range " + DA_GetRange(korpse));
  733.  
  734. while(korpse && haveRevive == me.getMinionCount(skeltype) && iLoop++ < XP_ToRevive){
  735. //print("in loop: "+iLoop+" haveRevive = " + haveRevive + " minionCount = " + me.getMinionCount(skeltype));
  736. getIntoLOS(korpse);
  737. if(getDistance(me.x,me.y,korpse.x,korpse.y) <40){
  738. //print("Raising " + (reviveSkill == 70 ? "Skel": "Mage") + " from " + korpse.name + " from range " + getDistance(me,korpse));
  739. NTC_DoCast(reviveSkill,0,korpse.x,korpse.y,1);
  740. //delay(500);
  741. //delay(((typeof me.serverip !== "undefined") ? me.ping : 50));
  742. }
  743. }
  744. success = true;
  745. }
  746. else{
  747. break;
  748. }
  749. }
  750. delay(300);
  751. haveRevive = me.getMinionCount(skeltype);
  752. }
  753. return success;
  754. }
  755. function XP_MaxRevives(revSkill) {
  756. switch(revSkill){
  757. case 70:
  758. return((me.getSkill(70,1) < 4) ? me.getSkill(70,1) : 2 + Math.floor(me.getSkill(70,1) / 3));
  759. case 80:
  760. return((me.getSkill(80,1) < 4) ? me.getSkill(80,1) : 2 + Math.floor(me.getSkill(80,1) / 3));
  761. case 95:
  762. return(me.getSkill(95,1));
  763. }
  764. return false;
  765. }
  766. function XP_UseNecroCE(target) {
  767. if (!target || target.hp < 1 || (target.getStat(36) > 99 && target.getStat(39) > 99)) return;
  768. var CE_level = NTC_CheckSkill(74);
  769. var CEa = (CE_level - 1) / 3;
  770. var CE_rad = 2.6 + CEa;
  771. var bomb = getBodyTarget(25,target.x,target.y,CE_rad);
  772. //if (bomb && target && target.hp > 0 && me.mp > 20 && DA_GetRangeXY(target,bomb.x,bomb.y) <= CE_rad) {
  773. if (bomb && target && target.hp > 0 && me.mp > 20 && getDistance(target.x,target.y,bomb.x,bomb.y) <= CE_rad) {
  774. //DC_DoCast(74,0,bomb);
  775. NTC_DoCast(74,0, bomb);
  776. delay(100);
  777. }
  778. }
  779. function getBodyTarget(range,tagX,tagY,dist) {
  780. var body_target = false;
  781.  
  782. var BodyTarget = getUnit(1, null, DEAD_MODE);
  783. if(BodyTarget) do {
  784. if (BodyTarget.getStat(172) == 2 || BodyTarget.getState(105) == 0) {
  785. continue;
  786. }
  787. if (BodyTarget.getState(99) || BodyTarget.getState(104) || BodyTarget.getState(118)) {
  788. continue;
  789. }
  790. // Use NeverCount base monstat for traps, hydra, etc.
  791. if (getBaseStat(1,BodyTarget.classid,23)) {
  792. continue;
  793. }
  794. if(getDistance(me, BodyTarget) < (!range ? 25 : range) && !BodyTarget.getParent() &&
  795. /*BodyTarget.classid != 271 && BodyTarget.classid != 289 &&
  796. BodyTarget.classid != 290 && BodyTarget.classid != 291 &&
  797. BodyTarget.classid != 292 && BodyTarget.classid != 338 &&
  798. BodyTarget.classid != 351 && BodyTarget.classid != 352 &&
  799. BodyTarget.classid != 353 && BodyTarget.classid != 359 &&
  800. BodyTarget.classid != 363 && BodyTarget.classid != 364 &&
  801. BodyTarget.classid != 371 && BodyTarget.classid != 543 &&
  802. BodyTarget.classid != 561 && */
  803. getBaseStat(6, BodyTarget.classid, 8) &&
  804. (((me.area == 132 || me.area == 131) && ((me.x < 15099) && (me.x > 15088)) && ((me.y < 5022) && (me.y > 5006))) ||
  805. !checkCollision(me.area,me.x,me.y,3,BodyTarget.x,BodyTarget.y,3,7))) {
  806. var skipTarget=false;
  807. for(var tk = 0; tk<ignoreKorpse.length; tk++) {
  808. if(ignoreKorpse[tk] == BodyTarget.gid) {
  809. skipTarget=true;
  810. break;
  811. }
  812. }
  813. if (tagX && getDistance (tagX,tagY, BodyTarget.x,BodyTarget.y) > dist)
  814. skipTarget = true;
  815. if(!skipTarget) {
  816. ignoreKorpse.push(BodyTarget.gid);
  817. return BodyTarget;
  818. }
  819. }
  820. }while(BodyTarget.getNext(null,DEAD_MODE));
  821. return false;
  822. }
  823.  
  824. function NTA_PaladinAttackInt(target, boss, maxattacks){
  825. var _attackprimary;
  826. var _maxattacks = 0;
  827. var _usehand1, _usehand2;
  828. var _damagetype1, _damagetype2;
  829. var _range1, _range2;
  830. var _prehp1, _prehp2;
  831. var _nohit = true;
  832.  
  833. _attackprimary = boss ? NTConfig_AttackBoss : NTConfig_AttackOthers;
  834.  
  835. _usehand1 = NTC_IsLeftSkill(_attackprimary) ? 2 : NTC_HAND_RIGHT;
  836. _damagetype1 = NTA_GetDamageType(_attackprimary);
  837.  
  838. if(NTConfig_AttackSecondary > 0)
  839. {
  840. _usehand2 = NTC_IsLeftSkill(NTConfig_AttackSecondary) ? 2 : NTC_HAND_RIGHT;
  841. _damagetype2 = NTA_GetDamageType(NTConfig_AttackSecondary);
  842. }
  843.  
  844. switch(_attackprimary)
  845. {
  846. case 101: // Holy Bolt
  847. case 121: // Fist of the Heavens
  848. _range1 = 20;
  849. break;
  850. default:
  851. _range1 = 2;
  852. break;
  853. }
  854.  
  855. switch(NTConfig_AttackSecondary)
  856. {
  857. case 101: // Holy Bolt
  858. case 121: // Fist of the Heavens
  859. _range2 = 20;
  860. break;
  861. default:
  862. _range2 = 2;
  863. break;
  864. }
  865.  
  866. _prehp1 = target.hp;
  867.  
  868. while(_maxattacks++ < maxattacks && NTA_IsValidTarget(target, true) && target.hp > 0)
  869. {
  870. //print("--Sub Step 1");
  871.  
  872. if(checkCollision(me, target, 3))
  873. {
  874. if(boss)
  875. {
  876. if(_attackprimary == 101 || _attackprimary == 121)
  877. NTA_MoveCloseInt(target, Math.round(getDistance(me, target)/2));
  878. }
  879. else if(me.area != 131)
  880. return false;
  881. }
  882.  
  883. _prehp2 = target.hp;
  884.  
  885. //print("--Sub Step 2");
  886.  
  887. if(NTA_GetResistance(target, _damagetype1) < 100)
  888. {
  889. //print("--Sub Step 3A");
  890.  
  891. if((_maxattacks % 2) == 1 && _nohit)
  892. {
  893. if(_attackprimary == 112)
  894. {
  895. //print("--Sub Step 3A-B");
  896. if(!NTM_MoveTo(target.x+1, target.y, 0) && !boss)
  897. return false;
  898. }
  899. else
  900. {
  901. //print("--Sub Step 3A-C");
  902. if(!NTA_MoveCloseInt(target, _range1) && !boss)
  903. return false;
  904. }
  905.  
  906. //print("--Sub Step 3A-D");
  907.  
  908. if(NTConfig_PutAura > 0)
  909. NTC_PutSkill(NTConfig_PutAura, NTC_HAND_RIGHT);
  910. }
  911.  
  912. //print("--Sub Step 3A-E");
  913.  
  914. NTC_DoCast(_attackprimary, _usehand1, target);
  915.  
  916. //print("--Sub Step 3A-F");
  917.  
  918. NTSI_FastSnag();
  919.  
  920. //print("--Sub Step 4A");
  921. }
  922. else if(NTConfig_AttackSecondary > 0 && NTA_GetResistance(target, _damagetype2) < 100)
  923. {
  924. //print("--Sub Step 3B");
  925.  
  926. if((_maxattacks % 2) == 1 && _nohit)
  927. {
  928. if(NTConfig_AttackSecondary == 112)
  929. {
  930. if(!NTM_MoveTo(target.x+1, target.y, 0) && !boss)
  931. return false;
  932. }
  933. else
  934. {
  935. if(!NTA_MoveCloseInt(target, _range2) && !boss)
  936. return false;
  937. }
  938.  
  939. if(NTConfig_PutAura > 0)
  940. NTC_PutSkill(NTConfig_PutAura, NTC_HAND_RIGHT);
  941. }
  942.  
  943. NTC_DoCast(NTConfig_AttackSecondary, _usehand2, target);
  944. NTSI_FastSnag();
  945.  
  946. //print("--Sub Step 4B");
  947. }
  948. else
  949. {
  950. //print("--Sub Step 3C");
  951. if(boss)
  952. {
  953. if((_maxattacks % 2) == 1 && _nohit)
  954. {
  955. if(_attackprimary == 112)
  956. NTM_MoveTo(target.x+1, target.y, 0);
  957. else
  958. NTA_MoveCloseInt(target, _range1);
  959.  
  960. if(NTConfig_PutAura > 0)
  961. NTC_PutSkill(NTConfig_PutAura, NTC_HAND_RIGHT);
  962. }
  963.  
  964. NTC_DoCast(_attackprimary, _usehand1, target);
  965. NTSI_FastSnag();
  966. }
  967. else
  968. return false;
  969. //print("--Sub Step 4C");
  970. }
  971.  
  972. //print("--Sub Step 4");
  973.  
  974. if(boss)
  975. {
  976. if((_maxattacks % 8) == 0)
  977. {
  978. if(target.hp < _prehp1)
  979. _prehp1 = target.hp;
  980. else
  981. return false;
  982. }
  983. }
  984. else
  985. {
  986. if((_maxattacks % 4) == 0)
  987. {
  988. if(target.hp < _prehp1)
  989. _prehp1 = target.hp;
  990. else
  991. return false;
  992. }
  993. }
  994.  
  995. //print("--Sub Step 5");
  996.  
  997. _nohit = (target.hp >= _prehp2);
  998.  
  999. if(NTConfig_CheckSafe)
  1000. {
  1001. if(!NTTMGR_CheckSafe(1))
  1002. return false;
  1003. }
  1004.  
  1005. //print("--Sub Step 6");
  1006. }
  1007.  
  1008. return true;
  1009. }
  1010.  
  1011. function NTA_BarbarianAttackInt(target, boss, maxattacks)
  1012. {
  1013. var _attackprimary;
  1014. var _maxattacks = 0;
  1015. var _usehand1, _usehand2;
  1016. var _damagetype1, _damagetype2;
  1017. var _range1, _range2;
  1018. var _castx, _casty;
  1019.  
  1020. _attackprimary = boss ? NTConfig_AttackBoss : NTConfig_AttackOthers;
  1021.  
  1022. if(_attackprimary == 152)
  1023. _damagetype1 = NTA_DAMAGE_MAGIC;
  1024. else
  1025. _damagetype1 = NTA_GetDamageType(_attackprimary);
  1026. _usehand1 = NTC_IsLeftSkill(_attackprimary) ? 2 : NTC_HAND_RIGHT;
  1027.  
  1028. if(NTConfig_AttackSecondary > 0)
  1029. {
  1030. _usehand2 = NTC_IsLeftSkill(NTConfig_AttackSecondary) ? 2 : NTC_HAND_RIGHT;
  1031. if(NTConfig_AttackSecondary == 152)
  1032. _damagetype2 = NTA_DAMAGE_MAGIC;
  1033. else
  1034. _damagetype2 = NTA_GetDamageType(NTConfig_AttackSecondary);
  1035. }
  1036.  
  1037. switch(_attackprimary)
  1038. {
  1039. case 151:
  1040. _range1 = 7;
  1041. break;
  1042. default:
  1043. _range1 = 3;
  1044. break;
  1045. }
  1046.  
  1047. switch(NTConfig_AttackSecondary)
  1048. {
  1049. case 152:
  1050. _range2 = 2;
  1051. break;
  1052. default:
  1053. _range2 = 3;
  1054. break;
  1055. }
  1056.  
  1057. while(_maxattacks++ < maxattacks && NTA_IsValidTarget(target, true) && target.hp > 0)
  1058. {
  1059. if(_attackprimary == 151 && NTA_GetResistance(target, _damagetype1) < 100)
  1060. {
  1061. if(getDistance(me, target) > _range1)
  1062. NTA_MoveCloseInt(target, _range1);
  1063.  
  1064. _castx = target.x > me.x ? target.x+3 : target.x-3;
  1065. _casty = target.y > me.y ? target.y+3 : target.y-3;
  1066.  
  1067. if(me.mp > 30)
  1068. NTC_DoCast(_attackprimary, _usehand1, _castx, _casty);
  1069. else{
  1070. //NTA_MoveCloseInt(target, 2);
  1071. NTC_DoCast(144, NTC_HAND_RIGHT, target);
  1072. }
  1073.  
  1074. if(_maxattacks%10 == 1 && NTConfig_WarcryBoss > 0 && (target.spectype&0x01 || boss) && target.hp > 0)
  1075. NTC_DoCast(NTConfig_WarcryBoss, NTC_HAND_RIGHT, target);
  1076. else if(_maxattacks%5 == 1 && NTConfig_WarcryOthers > 0 && target.hp > 0 && !boss && !(target.spectype&0x01))
  1077. NTC_DoCast(NTConfig_WarcryOthers, NTC_HAND_RIGHT, target);
  1078. }
  1079. else if(_attackprimary != 151 && NTA_GetResistance(target, _damagetype1) < 100)
  1080. {
  1081. if(getDistance(me, target) > _range1)
  1082. NTA_MoveCloseInt(target, _range1);
  1083.  
  1084. NTC_DoCast(_attackprimary, _usehand1, target);
  1085. }
  1086. else if(NTConfig_AttackSecondary > 0 && NTA_GetResistance(target, _damagetype2) < 100)
  1087. {
  1088. if(getDistance(me, target) > _range2)
  1089. NTA_MoveCloseInt(target, _range2);
  1090.  
  1091. NTC_DoCast(NTConfig_AttackSecondary, _usehand2, target);
  1092. }
  1093.  
  1094. //probably needs some more checks added later
  1095.  
  1096. if(NTConfig_CheckSafe)
  1097. {
  1098. if(!NTTMGR_CheckSafe(1))
  1099. return false;
  1100. }
  1101.  
  1102. NTC_Delay(10);
  1103. }
  1104.  
  1105. NTSI_FastSnag();
  1106. return true;
  1107. }
  1108.  
  1109. function NTA_DruidAttackInt(target, boss, maxattacks)
  1110. {
  1111. var _attackprimary;
  1112. var _primaryindex = boss ? 1 : 2;
  1113. var _maxattacks = 0;
  1114. var _usehand1, _usehand2;
  1115. var _damagetype1, _damagetype2;
  1116. var _range1, _range2;
  1117. var _prehp;
  1118.  
  1119. _attackprimary = boss ? NTConfig_AttackBoss : NTConfig_AttackOthers;
  1120.  
  1121. _usehand1 = NTC_IsLeftSkill(_attackprimary) ? 2 : NTC_HAND_RIGHT;
  1122. _damagetype1 = NTA_GetDamageType(_attackprimary);
  1123.  
  1124. if(NTConfig_AttackSecondary > 0)
  1125. {
  1126. _usehand2 = NTC_IsLeftSkill(NTConfig_AttackSecondary) ? 2 : NTC_HAND_RIGHT;
  1127. _damagetype2 = NTA_GetDamageType(NTConfig_AttackSecondary);
  1128. }
  1129.  
  1130. switch(_attackprimary)
  1131. {
  1132. case 245: // Tornado
  1133. _range1 = 2;
  1134. break;
  1135. default:
  1136. _range1 = 2;
  1137. break;
  1138. }
  1139.  
  1140. switch(NTConfig_AttackSecondary)
  1141. {
  1142. case 245: // Tornado
  1143. _range2 = 2;
  1144. break;
  1145. default:
  1146. _range2 = 2;
  1147. break;
  1148. }
  1149.  
  1150.  
  1151.  
  1152. _prehp = target.hp;
  1153.  
  1154. while(_maxattacks++ < maxattacks && NTA_IsValidTarget(target, true))
  1155. {
  1156. NTSI_FastSnag();
  1157.  
  1158. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) < 100)
  1159. {
  1160. if((_maxattacks % 2) == 1)
  1161. {
  1162. if(!NTA_MoveCloseInt(target, _range1) && !boss)
  1163. return false;
  1164. }
  1165.  
  1166. NTA_DoCastInt(_primaryindex, target);
  1167.  
  1168. if (!me.getState(149)) //refresh oak sage
  1169. NTC_DoCast(226,0);
  1170.  
  1171. if (!me.getState(144)) //refresh hurricane
  1172. NTC_DoCast(250,0);
  1173.  
  1174. if (!me.getState(151)) //refresh Cyclone Armor
  1175. NTC_DoCast(235,0);
  1176. }
  1177. else if(NTConfig_AttackSkill[4] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[4]) < 100)
  1178. {
  1179. if((_maxattacks % 2) == 1)
  1180. {
  1181. if(!NTA_MoveCloseInt(target, _range2) && !boss)
  1182. return false;
  1183. }
  1184.  
  1185. NTA_DoCastInt(4, target);
  1186.  
  1187. if (!me.getState(149)) //refresh oak sage
  1188. NTC_DoCast(226,0);
  1189.  
  1190. if (!me.getState(144)) //refresh hurricane
  1191. NTC_DoCast(250,0);
  1192.  
  1193. if (!me.getState(151)) //refresh Cyclone Armor
  1194. NTC_DoCast(235,0);
  1195.  
  1196. }
  1197. else
  1198. {
  1199. if(boss)
  1200. {
  1201. if((_maxattacks % 2) == 1)
  1202. NTA_MoveCloseInt(target, _range1);
  1203.  
  1204. NTA_DoCastInt(_primaryindex, target);
  1205.  
  1206. if (!me.getState(149)) //refresh oak sage
  1207. NTC_DoCast(226,0);
  1208.  
  1209. if (!me.getState(144)) //refresh hurricane
  1210. NTC_DoCast(250,0);
  1211.  
  1212. if (!me.getState(151)) //refresh Cyclone Armor
  1213. NTC_DoCast(235,0);
  1214.  
  1215.  
  1216. }
  1217. else
  1218. return false;
  1219. }
  1220.  
  1221. if(boss)
  1222. {
  1223. if((_maxattacks % 4) == 0 && target.hp >= _prehp)
  1224. {
  1225. if(target.classid == 526)
  1226. return false;
  1227. }
  1228.  
  1229. if((_maxattacks % 8) == 0)
  1230. {
  1231. if(target.hp < _prehp)
  1232. _prehp = target.hp;
  1233. else
  1234. return false;
  1235. }
  1236. }
  1237. else
  1238. {
  1239. if((_maxattacks % 4) == 0)
  1240. {
  1241. if(target.hp < _prehp)
  1242. _prehp = target.hp;
  1243. else
  1244. return false;
  1245. }
  1246. }
  1247.  
  1248. if(NTConfig_CheckSafe)
  1249. {
  1250. if(!NTTMGR_CheckSafe(1))
  1251. return false;
  1252. }
  1253. }
  1254. NTSI_FastSnag();
  1255. return true;
  1256. }
  1257.  
  1258. function NTA_AssassinAttackInt(target, boss, maxattacks)
  1259. {
  1260. var _primaryindex;
  1261. var _maxattacks = 0;
  1262. var _range1, _range2;
  1263. var _prehp;
  1264.  
  1265. _primaryindex = boss ? 1 : 2;
  1266.  
  1267. switch(NTConfig_AttackSkill[_primaryindex])
  1268. {
  1269. case 256: // Shock Field
  1270. case 271: // Lightning Sentry
  1271. _range1 = 10;
  1272. break;
  1273. default:
  1274. _range1 = 20;
  1275. break;
  1276. }
  1277.  
  1278. switch(NTConfig_AttackSkill[4])
  1279. {
  1280. case 256: // Shock Field
  1281. case 271: // Lightning Sentry
  1282. _range2 = 10;
  1283. break;
  1284. default:
  1285. _range2 = 20;
  1286. break;
  1287. }
  1288.  
  1289. _prehp = target.hp;
  1290.  
  1291. while(_maxattacks++ < maxattacks && NTA_IsValidTarget(target, true) && target.hp > 0)
  1292. {
  1293. if(NTConfig_UseTraps)
  1294. NTA_CheckTraps(target,boss);
  1295. NTSI_FastSnag();
  1296. if(!target.hp > 0)
  1297. break;
  1298. if(!getCollision(me.area, target.x,target.y))
  1299. {
  1300. if(boss)
  1301. NTA_MoveCloseInt(target, Math.round(getDistance(me, target)/2));
  1302. else if(me.area != 131)
  1303. return false;
  1304. }
  1305.  
  1306. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) < 100)
  1307. {
  1308. if((_maxattacks % 2) == 1)
  1309. {
  1310. if(!NTA_MoveCloseInt(target, _range1) && !boss)
  1311. return false;
  1312. }
  1313.  
  1314. NTA_DoCastInt(_primaryindex, target);
  1315. }
  1316. else if(NTConfig_AttackSkill[4] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[4]) < 100)
  1317. {
  1318. if((_maxattacks % 2) == 1)
  1319. {
  1320. if(!NTA_MoveCloseInt(target, _range2) && !boss)
  1321. return false;
  1322. }
  1323.  
  1324. NTA_DoCastInt(4, target);
  1325. }
  1326. else
  1327. {
  1328. if(boss)
  1329. {
  1330. if((_maxattacks % 2) == 1)
  1331. NTA_MoveCloseInt(target, _range1);
  1332.  
  1333. NTA_DoCastInt(_primaryindex, target);
  1334. }
  1335. else
  1336. return false;
  1337. }
  1338.  
  1339. if(boss)
  1340. {
  1341. if((_maxattacks % 4) == 0 && target.hp >= _prehp)
  1342. {
  1343. if(target.classid == 526)
  1344. return false;
  1345. }
  1346.  
  1347. if((_maxattacks % 8) == 0)
  1348. {
  1349. if(target.hp < _prehp)
  1350. _prehp = target.hp;
  1351. else
  1352. return false;
  1353. }
  1354. }
  1355. else
  1356. {
  1357. if((_maxattacks % 4) == 0)
  1358. {
  1359. if(target.hp < _prehp)
  1360. _prehp = target.hp;
  1361. else
  1362. return false;
  1363. }
  1364. }
  1365.  
  1366. if(NTConfig_CheckSafe)
  1367. {
  1368. if(!NTTMGR_CheckSafe(1))
  1369. return false;
  1370. }
  1371. }
  1372.  
  1373. return true;
  1374. }
  1375. function NTA_CheckTraps(target,boss)
  1376. {
  1377. var traps=NTC_GetUnit(NTC_UNIT_MONSTER);
  1378. var trapcount =0;
  1379. var warr=0;
  1380. var secondTrap =276;
  1381. var x,y;
  1382. if (traps){
  1383. do{
  1384. if (traps.classid == 412 || traps.classid == 413 || traps.classid == 416 || traps.classid == 417){
  1385. if(traps.getParent() == me.name)
  1386. if(getDistance(target.x,target.y,traps.x,traps.y)<35 && traps.hp > 100 )
  1387. trapcount=trapcount+1;
  1388.  
  1389. }
  1390. if (traps.classid == 418 || traps.classid == 419 && traps.mode != 12){
  1391. warr=1;
  1392. }
  1393. }while(traps.getNext())
  1394. if (trapcount < 5 && target.hp>0){
  1395. x=target.x; y=target.y;
  1396.  
  1397.  
  1398. if(target.classid == 243 || target.classid == 544)
  1399. secondTrap =271;
  1400. NTSI_FastSnag();
  1401. NTC_DoCast(258, NTC_HAND_RIGHT); //quickness
  1402.  
  1403. NTSI_FastSnag();
  1404. NTC_DoCast(271, NTC_HAND_RIGHT, x+2,y);
  1405. NTC_DoCast(271, NTC_HAND_RIGHT, x+1,y);
  1406. NTSI_FastSnag();
  1407. NTC_DoCast(271, NTC_HAND_RIGHT, x,y);
  1408. NTSI_FastSnag();
  1409. NTC_DoCast(secondTrap, NTC_HAND_RIGHT, x-1,y);
  1410. NTC_DoCast(secondTrap, NTC_HAND_RIGHT, x-2,y);
  1411. if (NTConfig_CastFade)
  1412. NTC_DoCast(267, NTC_HAND_RIGHT); //fade
  1413. NTSI_FastSnag();
  1414. }
  1415. if (warr==0)
  1416. NTP_UpdatePrecast();
  1417. }
  1418.  
  1419. }
  1420. function NTA_MoveCloseInt(target, maxrange)
  1421. {
  1422. var _dist = getDistance(me, target);
  1423.  
  1424. if(_dist > maxrange)
  1425. {
  1426. var _destx, _desty;
  1427.  
  1428. _destx = me.x + Math.round((_dist-maxrange)*(target.x-me.x) / _dist);
  1429. _desty = me.y + Math.round((_dist-maxrange)*(target.y-me.y) / _dist);
  1430.  
  1431. return NTM_MoveTo(_destx, _desty, 0);
  1432. }
  1433.  
  1434. return true;
  1435. }
  1436.  
  1437. function NTA_SortRoomInt(a, b)
  1438. {
  1439. if(getDistance(me.x, me.y, a[0], a[1]) < getDistance(me.x, me.y, b[0], b[1]))
  1440. return -1;
  1441.  
  1442. return 1;
  1443. }
  1444.  
  1445. function NTA_Initialize()
  1446. {
  1447.  
  1448. if (me.classid == 1){
  1449. //NTConfig_AttackFirst=NTConfig_AttackSkill[0];
  1450. //NTConfig_AttackBoss=NTConfig_AttackSkill[1];
  1451. //NTConfig_AttackOthers=NTConfig_AttackSkill[2];
  1452. //NTConfig_AttackSecondary=NTConfig_AttackSkill[4];
  1453. //if (NTConfig_AttackSecondary == 0)
  1454. // NTConfig_AttackSecondary = NTConfig_AttackSkill[4];
  1455.  
  1456. if (NTConfig_AttackSkill[0] == 0 && NTConfig_AttackSkill[1] == 0 && NTConfig_AttackSkill[2] == 0 && NTConfig_AttackSkill[3] == 0 && NTConfig_AttackSkill[4] == 0 ){
  1457. // old config file
  1458. NTConfig_AttackSkill[0] = NTConfig_AttackFirst;
  1459. NTConfig_AttackSkill[1] = NTConfig_AttackBoss;
  1460. NTConfig_AttackSkill[2] = NTConfig_AttackOthers;
  1461. NTConfig_AttackSkill[4] = NTConfig_AttackSecondary;
  1462. }
  1463. }
  1464. for(var i = 0 ; i < 6 ; i++)
  1465. {
  1466. if(NTConfig_AttackSkill[i] > 0)
  1467. {
  1468. _NTA_SkillHand[i] = getBaseStat("skills.txt", NTConfig_AttackSkill[i], 166) ? 2 : NTC_HAND_RIGHT;
  1469. _NTA_SkillDamage[i] = NTA_GetDamageType(NTConfig_AttackSkill[i]);
  1470. _NTA_SkillDelay[i] = NTC_GetCastDelay(NTConfig_AttackSkill[i]);
  1471. }
  1472. }
  1473. }
  1474. function NTA_DoCastInt(index, target)
  1475. {
  1476. var _untimedindex = index < 4 ? 3 : 5;
  1477. if (NTConfig_AttackSkill[index] == 0)
  1478. return false;
  1479. if(!NTC_DoCast(NTConfig_AttackSkill[index], _NTA_SkillHand[index], target))
  1480. return false;
  1481.  
  1482. if (me.area != 102)
  1483. getIntoLOS(target)
  1484.  
  1485. if(_NTA_SkillDelay[index] > 0)
  1486. {
  1487. if(NTConfig_AttackSkill[_untimedindex] > 0)
  1488. {
  1489. var _starttick = getTickCount();
  1490.  
  1491. while(NTA_IsValidTarget(target, true))
  1492. {
  1493. NTC_DoCast(NTConfig_AttackSkill[_untimedindex], _NTA_SkillHand[_untimedindex], target);
  1494.  
  1495. if(getTickCount()-_starttick >= _NTA_SkillDelay[index])
  1496. break;
  1497. }
  1498. }
  1499. else
  1500. NTC_Delay(_NTA_SkillDelay[index]);
  1501. }
  1502.  
  1503. return true;
  1504. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!