API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 26th, 2017
65
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 31.59 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.  
  9. var _NTA_SkillHand = new Array(7);
  10. var _NTA_SkillDamage = new Array(7);
  11. var _NTA_SkillRange = new Array(7);
  12.  
  13. function NTA_Initialize()
  14. {
  15. if(NTConfig_AttackSkill[1] == 0 || NTConfig_AttackSkill[3] == 0)
  16. NTA_DetectAttackPattern();
  17.  
  18. for(var i = 0 ; i < 8 ; i++)
  19. {
  20. if(NTConfig_AttackSkill[i] > 0)
  21. {
  22. _NTA_SkillHand[i] = GetBaseStat("skills.txt", NTConfig_AttackSkill[i], 166) ? 2 : NTC_HAND_RIGHT;
  23. _NTA_SkillDamage[i] = NTA_GetDamageType(NTConfig_AttackSkill[i]);
  24.  
  25. switch(NTConfig_AttackSkill[i])
  26. {
  27. case 6: //magic arrow
  28.  
  29. case 7: //fire arrow
  30. _NTA_Skillrange[i] = 15;
  31. break;
  32.  
  33. case 10: //jab
  34. _NTA_Skillrange[i] = 3;
  35. break;
  36.  
  37. case 11: //cold arrow
  38.  
  39. case 12: //multiple shot
  40.  
  41. case 16: //exploding arrow
  42.  
  43. case 21: //ice arrow
  44.  
  45. case 22: //guided arrow
  46. _NTA_Skillrange[i] = 20;
  47. break;
  48.  
  49. case 24: //charged strike
  50. _NTA_Skillrange[i] = 3;
  51. break;
  52.  
  53. case 25: //plague jav
  54. _NTA_Skillrange[i] = 10;
  55. break;
  56.  
  57. case 35: //Lightning Fury
  58. _NTA_Skillrange[i] = 12;
  59. break;
  60.  
  61. default:
  62. _NTA_SkillRange[i] = 25;
  63. break;
  64. }
  65. }
  66. }
  67. }
  68.  
  69. function NTA_KillMonster(classid)
  70. {
  71. var _target;
  72.  
  73. if(NTConfig_AttackSkill[1] < 1)
  74. return false;
  75.  
  76. _target = NTC_FindUnit(NTC_UNIT_MONSTER, classid, 5);
  77.  
  78. if(!_target)
  79. return false;
  80.  
  81. if(_target.IsAttackable())
  82. {
  83. var _attackcount = 0;
  84.  
  85. while(_attackcount < 300 && NTA_IsValidMonster(_target))
  86. {
  87. if(NTA_Attack(_target, (_attackcount%30) == 0) < 2)
  88. break;
  89.  
  90. _attackcount++;
  91. }
  92. }
  93.  
  94. return (_target.hp <= 0 || _target.mode == 0 || _target.mode == 12);
  95. }
  96.  
  97. function NTA_ClearPosition(range, pickitem, safelevel)
  98. {
  99. var _orgx, _orgy;
  100. var _spectype = [0x0A, 0x01, 0x01];
  101. var _skiplist;
  102. var _attackcount = 0;
  103. var _target;
  104. var _distance, _mingid, _mindistance;
  105. var _result;
  106.  
  107. if(NTConfig_AttackSkill[1] < 1 || NTConfig_AttackSkill[3] < 1)
  108. return false;
  109.  
  110. switch(arguments.length)
  111. {
  112. case 0:
  113. range = 20;
  114. case 1:
  115. pickitem = false;
  116. case 2:
  117. safelevel = 0;
  118. default:
  119. if(NTConfig_CheckSelfSafe < 0x01 && NTConfig_CheckMercSafe < 0x01)
  120. safelevel = 0;
  121. break;
  122. }
  123.  
  124. _orgx = me.x;
  125. _orgy = me.y;
  126.  
  127. for(var i = 0 ; i < _spectype.length ; i++)
  128. {
  129. _skiplist = new Array();
  130.  
  131. while(_attackcount < (i+1)*100)
  132. {
  133. _mindistance = 100000;
  134.  
  135. _target = NTC_FindUnit(NTC_UNIT_MONSTER);
  136.  
  137. NTSI_PickItems();
  138.  
  139. if(_target)
  140. {
  141. do
  142. {
  143. if(_skiplist.indexOf(_target.gid) < 0)
  144. {
  145. if(_target.IsAttackable() && (_target.spectype&_spectype[i]))
  146. {
  147. if(GetDistance(_orgx, _orgy, _target.x, _target.y) <= range && NTA_IsValidMonster(_target))
  148. {
  149. _distance = GetDistance(me, _target);
  150.  
  151. if(_distance < _mindistance)
  152. {
  153. _mingid = _target.gid;
  154. _mindistance = _distance;
  155. }
  156. }
  157. }
  158. else
  159. _skiplist.push(_target.gid);
  160. }
  161. } while(_target.GetNext());
  162. }
  163.  
  164. if(_mindistance < 100000)
  165. {
  166. _target = NTC_FindUnit(NTC_UNIT_MONSTER, _mingid);
  167.  
  168. if(_target)
  169. {
  170. _result = NTA_Attack(_target, (_attackcount%30) == 0);
  171.  
  172. switch(_result)
  173. {
  174. case 1:
  175. _skiplist.push(_mingid);
  176. break;
  177. case 2:
  178. case 3:
  179. _attackcount++;
  180. break;
  181. default:
  182. return false;
  183. }
  184. }
  185. }
  186. else
  187. break;
  188. }
  189. }
  190.  
  191. if(me.classid == NTC_CHAR_CLASS_PALADIN)
  192. {
  193. if(_attackcount > 2 && (parseInt(me.hp*100/me.hpmax) < NTConfig_UseRedemptionHP || parseInt(me.mp*100/me.mpmax) < NTConfig_UseRedemptionMP))
  194. {
  195. if(NTC_PutSkill(124, NTC_HAND_RIGHT))
  196. NTC_PingDelay(1000);
  197. }
  198. }
  199.  
  200. if(NTConfig_OpenChest)
  201. {
  202. _target = NTC_GetSpecialChest();
  203.  
  204. if(_target && GetDistance(_orgx, _orgy, _target.x, _target.y) <= range && NTC_OpenChest(_target))
  205. _attackcount++;
  206. }
  207.  
  208. if(pickitem && _attackcount > 0)
  209. NTSI_PickItems();
  210.  
  211. switch(safelevel)
  212. {
  213. case 1:
  214. return NTTMGR_CheckSafe(0x00, NTConfig_CheckMercSafe&0x01);
  215. case 2:
  216. return NTTMGR_CheckSafe(NTConfig_CheckSelfSafe, NTConfig_CheckMercSafe);
  217. }
  218.  
  219. return true;
  220. }
  221. function NTA_ClearActLevel(pickitem, safelevel)
  222. {
  223. var i;
  224. var _room, _rooms;
  225. var _distance, _minindex, _mindistance;
  226.  
  227. _room = GetRoom();
  228.  
  229. if(!_room)
  230. return false;
  231.  
  232. switch(arguments.length)
  233. {
  234. case 0:
  235. pickitem = true;
  236. case 1:
  237. safelevel = 2;
  238. default:
  239. if(NTConfig_CheckSelfSafe < 0x01 && NTConfig_CheckMercSafe < 0x01)
  240. safelevel = 0;
  241. break;
  242. }
  243.  
  244. _rooms = new Array();
  245.  
  246. do
  247. {
  248. _rooms.push([parseInt(_room.x*5 + _room.xsize*5/2), parseInt(_room.y*5 + _room.ysize*5/2)]);
  249. } while(_room.GetNext());
  250.  
  251. while(_rooms.length > 0)
  252. {
  253. _mindistance = 100000;
  254.  
  255. for(i = 0 ; i < _rooms.length ; i++)
  256. {
  257. _distance = GetDistance(me.x, me.y, _rooms[i][0], _rooms[i][1]);
  258.  
  259. if(_distance < _mindistance)
  260. {
  261. _minindex = i;
  262. _mindistance = _distance;
  263. }
  264. }
  265.  
  266. if(NTM_MoveTo(me.areaid, _rooms[_minindex][0], _rooms[_minindex][1], 1))
  267. {
  268. if(!NTA_ClearActArea(pickitem, safelevel))
  269. return false;
  270.  
  271. NTP_DoPrecast(false);
  272. }
  273.  
  274. _rooms.splice(_minindex, 1);
  275. }
  276.  
  277. return true;
  278. }
  279.  
  280. function NTA_ClearActArea(pickitem, safelevel) //start
  281. {
  282. var _room;
  283. var _spectype = [0x0A];
  284. var _skiplist;
  285. var _attackcount = 0;
  286. var _target;
  287. var _distance, _mingid, _mindistance;
  288. var _result;
  289.  
  290. if(NTConfig_AttackSkill[1] < 1 || NTConfig_AttackSkill[3] < 1)
  291. return false;
  292.  
  293. _room = me.GetRoom();
  294.  
  295. if(!_room)
  296. return false;
  297.  
  298. switch(arguments.length)
  299. {
  300. case 0:
  301. pickitem = false;
  302. case 1:
  303. safelevel = 0;
  304. default:
  305. if(NTConfig_CheckSelfSafe < 0x01 && NTConfig_CheckMercSafe < 0x01)
  306. safelevel = 0;
  307. break;
  308. }
  309.  
  310. for(var i = 0 ; i < _spectype.length ; i++)
  311. {
  312. _skiplist = new Array();
  313.  
  314. while(_attackcount < (i+1)*100)
  315. {
  316. _mindistance = 100000;
  317.  
  318. _target = NTC_FindUnit(NTC_UNIT_MONSTER);
  319.  
  320. if(_target)
  321. {
  322. do
  323. {
  324. if(_skiplist.indexOf(_target.gid) < 0)
  325. {
  326. if(_target.IsAttackable() && (_target.spectype&_spectype[i]))
  327. {
  328. if(_room.UnitInRoom(_target) && NTA_IsValidMonster(_target))
  329. {
  330. _distance = GetDistance(me, _target);
  331.  
  332. if(_distance < _mindistance)
  333. {
  334. _mingid = _target.gid;
  335. _mindistance = _distance;
  336. }
  337. }
  338. }
  339. else
  340. _skiplist.push(_target.gid);
  341. }
  342. } while(_target.GetNext());
  343. }
  344.  
  345. if(_mindistance < 100000)
  346. {
  347. _target = NTC_FindUnit(NTC_UNIT_MONSTER, _mingid);
  348.  
  349. if(_target)
  350. {
  351. _result = NTA_Attack(_target, (_attackcount%30) == 0);
  352.  
  353. switch(_result)
  354. {
  355. case 1:
  356. _skiplist.push(_mingid);
  357. break;
  358. case 2:
  359. case 3:
  360. _attackcount++;
  361. break;
  362. default:
  363. return false;
  364. }
  365. }
  366. }
  367. else
  368. break;
  369. }
  370. }
  371.  
  372. if(me.classid == NTC_CHAR_CLASS_PALADIN)
  373. {
  374. if(_attackcount > 2 && (parseInt(me.hp*100/me.hpmax) < NTConfig_UseRedemptionHP || parseInt(me.mp*100/me.mpmax) < NTConfig_UseRedemptionMP))
  375. {
  376. if(NTC_PutSkill(124, NTC_HAND_RIGHT))
  377. NTC_PingDelay(1000);
  378. }
  379. }
  380.  
  381. if(NTConfig_OpenChest)
  382. {
  383. _target = NTC_GetSpecialChest();
  384.  
  385. if(_target && _room.UnitInRoom(_target) && NTC_OpenChest(_target))
  386. _attackcount++;
  387. }
  388.  
  389. if(pickitem && _attackcount > 0)
  390. NTSI_PickItems();
  391.  
  392. switch(safelevel)
  393. {
  394. case 1:
  395. return NTTMGR_CheckSafe(0x00, NTConfig_CheckMercSafe&0x01);
  396. case 2:
  397. return NTTMGR_CheckSafe(NTConfig_CheckSelfSafe, NTConfig_CheckMercSafe);
  398. }
  399.  
  400. return true;
  401. }//end
  402.  
  403. function NTA_ClearLevel(pickitem, safelevel)
  404. {
  405. var i;
  406. var _room, _rooms;
  407. var _distance, _minindex, _mindistance;
  408.  
  409. _room = GetRoom();
  410.  
  411. if(!_room)
  412. return false;
  413.  
  414. switch(arguments.length)
  415. {
  416. case 0:
  417. pickitem = true;
  418. case 1:
  419. safelevel = 2;
  420. default:
  421. if(NTConfig_CheckSelfSafe < 0x01 && NTConfig_CheckMercSafe < 0x01)
  422. safelevel = 0;
  423. break;
  424. }
  425.  
  426. _rooms = new Array();
  427.  
  428. do
  429. {
  430. _rooms.push([parseInt(_room.x*5 + _room.xsize*5/2), parseInt(_room.y*5 + _room.ysize*5/2)]);
  431. } while(_room.GetNext());
  432.  
  433. while(_rooms.length > 0)
  434. {
  435. _mindistance = 100000;
  436.  
  437. for(i = 0 ; i < _rooms.length ; i++)
  438. {
  439. _distance = GetDistance(me.x, me.y, _rooms[i][0], _rooms[i][1]);
  440.  
  441. if(_distance < _mindistance)
  442. {
  443. _minindex = i;
  444. _mindistance = _distance;
  445. }
  446. }
  447.  
  448. if(NTM_MoveTo(me.areaid, _rooms[_minindex][0], _rooms[_minindex][1], 1))
  449. {
  450. if(!NTA_ClearRoom(pickitem, safelevel))
  451. return false;
  452.  
  453. NTP_DoPrecast(false);
  454. }
  455.  
  456. _rooms.splice(_minindex, 1);
  457. }
  458.  
  459. return true;
  460. }
  461.  
  462. function NTA_ClearRoom(pickitem, safelevel)
  463. {
  464. var _room;
  465. var _spectype = [0x0A, 0x01, 0x01];
  466. var _skiplist;
  467. var _attackcount = 0;
  468. var _target;
  469. var _distance, _mingid, _mindistance;
  470. var _result;
  471.  
  472. if(NTConfig_AttackSkill[1] < 1 || NTConfig_AttackSkill[3] < 1)
  473. return false;
  474.  
  475. _room = me.GetRoom();
  476.  
  477. if(!_room)
  478. return false;
  479.  
  480. switch(arguments.length)
  481. {
  482. case 0:
  483. pickitem = false;
  484. case 1:
  485. safelevel = 0;
  486. default:
  487. if(NTConfig_CheckSelfSafe < 0x01 && NTConfig_CheckMercSafe < 0x01)
  488. safelevel = 0;
  489. break;
  490. }
  491.  
  492. for(var i = 0 ; i < _spectype.length ; i++)
  493. {
  494. _skiplist = new Array();
  495.  
  496. while(_attackcount < (i+1)*100)
  497. {
  498. _mindistance = 100000;
  499.  
  500. _target = NTC_FindUnit(NTC_UNIT_MONSTER);
  501.  
  502. if(_target)
  503. {
  504. do
  505. {
  506. if(_skiplist.indexOf(_target.gid) < 0)
  507. {
  508. if(_target.IsAttackable() && (_target.spectype&_spectype[i]))
  509. {
  510. if(_room.UnitInRoom(_target) && NTA_IsValidMonster(_target))
  511. {
  512. _distance = GetDistance(me, _target);
  513.  
  514. if(_distance < _mindistance)
  515. {
  516. _mingid = _target.gid;
  517. _mindistance = _distance;
  518. }
  519. }
  520. }
  521. else
  522. _skiplist.push(_target.gid);
  523. }
  524. } while(_target.GetNext());
  525. }
  526.  
  527. if(_mindistance < 100000)
  528. {
  529. _target = NTC_FindUnit(NTC_UNIT_MONSTER, _mingid);
  530.  
  531. if(_target)
  532. {
  533. _result = NTA_Attack(_target, (_attackcount%30) == 0);
  534.  
  535. switch(_result)
  536. {
  537. case 1:
  538. _skiplist.push(_mingid);
  539. break;
  540. case 2:
  541. case 3:
  542. _attackcount++;
  543. break;
  544. default:
  545. return false;
  546. }
  547. }
  548. }
  549. else
  550. break;
  551. }
  552. }
  553.  
  554. if(me.classid == NTC_CHAR_CLASS_PALADIN)
  555. {
  556. if(_attackcount > 2 && (parseInt(me.hp*100/me.hpmax) < NTConfig_UseRedemptionHP || parseInt(me.mp*100/me.mpmax) < NTConfig_UseRedemptionMP))
  557. {
  558. if(NTC_PutSkill(124, NTC_HAND_RIGHT))
  559. NTC_PingDelay(1000);
  560. }
  561. }
  562.  
  563. if(NTConfig_OpenChest)
  564. {
  565. _target = NTC_GetSpecialChest();
  566.  
  567. if(_target && _room.UnitInRoom(_target) && NTC_OpenChest(_target))
  568. _attackcount++;
  569. }
  570.  
  571. if(pickitem && _attackcount > 0)
  572. NTSI_PickItems();
  573.  
  574. switch(safelevel)
  575. {
  576. case 1:
  577. return NTTMGR_CheckSafe(0x00, NTConfig_CheckMercSafe&0x01);
  578. case 2:
  579. return NTTMGR_CheckSafe(NTConfig_CheckSelfSafe, NTConfig_CheckMercSafe);
  580. }
  581.  
  582. return true;
  583. }
  584.  
  585. function NTA_IsValidMonster(monster)
  586. {
  587. var _classid;
  588.  
  589. if(monster.hp <= 0 || monster.mode == 0 || monster.mode == 12)
  590. return false;
  591.  
  592. _classid = monster.classid;
  593.  
  594. if(((_classid >= 110 && _classid <= 113) || _classid == 608) && monster.mode == 8) // ignore flying scavengers
  595. return false;
  596.  
  597. if(_classid == 68 && monster.mode == 14) // ignore burrowing maggots
  598. return false;
  599.  
  600. if(_classid >= 258 && _classid <= 263 && monster.mode == 14) // ignore submerged WaterWatchers
  601. return false;
  602.  
  603. if(_classid == 21 || _classid == 162 || _classid == 55) //Ignore all in Tower except Ghosts and Countess+CountessMinions
  604. return false;
  605.  
  606. if(_classid == 21 || _classid == 162 || _classid == 55) //Ignore all in Tower except Ghosts and Countess+CountessMinions
  607. return false;
  608.  
  609. if(monster.GetState(53) || monster.GetState(96)) // Conversion, Revive
  610. return false;
  611.  
  612. return true;
  613. }
  614.  
  615. function NTA_GetDamageType(skillid)
  616. {
  617. if(skillid == 74) // Corpse Explosion
  618. return NTA_DAMAGE_PHYSICAL;
  619.  
  620. if(skillid == 112) // Blessed Hammer
  621. return NTA_DAMAGE_NONE;
  622.  
  623. switch(GetBaseStat("skills.txt", skillid, 233))
  624. {
  625. case "cold":
  626. return NTA_DAMAGE_COLD;
  627. case "fire":
  628. return NTA_DAMAGE_FIRE;
  629. case "ltng":
  630. return NTA_DAMAGE_LIGHTNING;
  631. case "mag":
  632. return NTA_DAMAGE_MAGIC;
  633. case "pois":
  634. return NTA_DAMAGE_POISON;
  635. case "stun":
  636. return NTA_DAMAGE_NONE;
  637. default:
  638. if(GetBaseStat("skills.txt", skillid, 178) || GetBaseStat("skills.txt", skillid, 182)) // aura or passive
  639. return NTA_DAMAGE_NONE;
  640. }
  641.  
  642. return NTA_DAMAGE_PHYSICAL;
  643. }
  644.  
  645. function NTA_GetResistance(enemy, type)
  646. {
  647. switch(type)
  648. {
  649. case NTA_DAMAGE_PHYSICAL:
  650. return enemy.GetStat(36);
  651. case NTA_DAMAGE_MAGIC:
  652. return enemy.GetStat(37);
  653. case NTA_DAMAGE_FIRE:
  654. return enemy.GetStat(39);
  655. case NTA_DAMAGE_LIGHTNING:
  656. return enemy.GetStat(41);
  657. case NTA_DAMAGE_COLD:
  658. return enemy.GetStat(43);
  659. case NTA_DAMAGE_POISON:
  660. return enemy.GetStat(45);
  661. }
  662.  
  663. return 0;
  664. }
  665.  
  666. function NTA_DetectAttackPattern()
  667. {
  668. switch(me.classid)
  669. {
  670. case NTC_CHAR_CLASS_AMAZON:
  671. return NTA_AmazonAttackPatternInt();
  672. case NTC_CHAR_CLASS_SORCERESS:
  673. return NTA_SorceressAttackPatternInt();
  674. case NTC_CHAR_CLASS_NECROMANCER:
  675. return NTA_NecromancerAttackPatternInt();
  676. case NTC_CHAR_CLASS_PALADIN:
  677. return NTA_PaladinAttackPatternInt();
  678. case NTC_CHAR_CLASS_BARBARIAN:
  679. return NTA_BarbarianAttackPatternInt();
  680. case NTC_CHAR_CLASS_DRUID:
  681. return NTA_DruidAttackPatternInt();
  682. case NTC_CHAR_CLASS_ASSASSIN:
  683. return NTA_AssassinAttackPatternInt();
  684. }
  685.  
  686. return false;
  687. }
  688.  
  689. // Return value : 0 = Unrecoverable process, 1 = Unavailable attack, 2 = Onetime fail, 3 = Success
  690. function NTA_Attack(target, firstorder)
  691. {
  692. switch(me.classid)
  693. {
  694. case NTC_CHAR_CLASS_AMAZON:
  695. return NTA_AmazonAttackInt(target, firstorder);
  696. case NTC_CHAR_CLASS_SORCERESS:
  697. return NTA_SorceressAttackInt(target, firstorder);
  698. case NTC_CHAR_CLASS_NECROMANCER:
  699. return NTA_NecromancerAttackInt(target, firstorder);
  700. case NTC_CHAR_CLASS_PALADIN:
  701. return NTA_PaladinAttackInt(target, firstorder);
  702. case NTC_CHAR_CLASS_BARBARIAN:
  703. return NTA_BarbarianAttackInt(target, firstorder);
  704. case NTC_CHAR_CLASS_DRUID:
  705. return NTA_DruidAttackInt(target, firstorder);
  706. case NTC_CHAR_CLASS_ASSASSIN:
  707. return NTA_AssassinAttackInt(target, firstorder);
  708. }
  709.  
  710. return 0;
  711. }
  712.  
  713.  
  714. function NTA_IsWeaponBroken()
  715. {
  716. var _weapon;
  717. _weapon = me.GetItems();
  718.  
  719. if(_weapon)
  720. {
  721. for(var i = 0 ; i < _weapon.length ; i++)
  722. {
  723. if(_weapon[i].itemflag&0x100)
  724. {
  725. if(_weapon[i].mode == 1 && _weapon[i].itemloc == 4 || _weapon[i].itemloc == 5)
  726. {
  727. Print("ÿc8My weapon broke, I am going to town to repair it.")
  728. NTTMGR_VisitTown();
  729. NTTMGR_TownManager();
  730. break;
  731.  
  732. }
  733. }
  734. }
  735. }
  736. }
  737.  
  738. function NTA_HaveArrows()
  739. {
  740. var _weapon;
  741. var _haveAmmo = false;
  742. _weapon = me.GetItems();
  743.  
  744. if(_weapon)
  745. {
  746. for(var i = 0 ; i < _weapon.length ; i++)
  747. {
  748. if((_weapon[i].classid == 526 || _weapon[i].classid == 528) && _weapon[i].itemloc == 5)
  749. {
  750. if(_weapon[i].GetStat(70) < 10)
  751. {
  752. Print("ÿc8I'm low on "+ _weapon[i].name + ", I am going to town to buy more.")
  753. NTTMGR_VisitTown();
  754. NTTMGR_TownManager();
  755. }
  756. _haveAmmo = true;
  757. break;
  758. }
  759. }
  760. }
  761.  
  762. if(!_haveAmmo)
  763. {
  764. Print("ÿc8I have no ammo, I am going to town to buy some.")
  765. NTTMGR_VisitTown();
  766. NTTMGR_TownManager();
  767. }
  768. }
  769. // Internal function
  770. function NTA_AmazonAttackPatternInt()
  771. {
  772.  
  773. var _maxindex, _maxskill;
  774. var _avgskilllevel = new Array();
  775.  
  776. _avgskilllevel[0] = me.GetSkill(35, false);
  777. _avgskilllevel[1] = parseInt((me.GetSkill(31, false) + me.GetSkill(11, false) + me.GetSkill(21, false)) /3 );
  778. _avgskilllevel[2] = me.GetSkill(26, false);
  779.  
  780.  
  781. _maxindex = -1;
  782. _maxskill = 0;
  783.  
  784. for(var i = 0 ; i < _avgskilllevel.length ; i++)
  785. {
  786. if(_avgskilllevel[i] > _maxskill)
  787. {
  788. _maxindex = i;
  789. _maxskill = _avgskilllevel[i];
  790. }
  791. }
  792.  
  793. switch(_maxindex)
  794. {
  795. case 0: // Lightning Fury for Javazon
  796.  
  797. NTConfig_AttackSkill[1] = 35;
  798. NTConfig_AttackSkill[2] = 35;
  799. NTConfig_AttackSkill[3] = 35;
  800. NTConfig_AttackSkill[4] = 35;
  801. NTConfig_AttackSkill[5] = 35;
  802. NTConfig_AttackSkill[6] = 35;
  803. NTConfig_AttackSkill[7] = 24;
  804. break;
  805.  
  806. case 1: // Freezing Arrow for Bowzon
  807.  
  808. NTConfig_AttackSkill[1] = 31;
  809. NTConfig_AttackSkill[2] = 31;
  810. NTConfig_AttackSkill[3] = 31;
  811. NTConfig_AttackSkill[4] = 31;
  812. NTConfig_AttackSkill[5] = 31;
  813. NTConfig_AttackSkill[6] = 31;
  814. NTConfig_AttackSkill[7] = 31;
  815. break;
  816.  
  817. case 2: // Cold Arrow + Strafe for Bowzon
  818.  
  819. NTConfig_AttackSkill[0] = 11;
  820. NTConfig_AttackSkill[1] = 26;
  821. NTConfig_AttackSkill[2] = 26;
  822. NTConfig_AttackSkill[3] = 26;
  823. NTConfig_AttackSkill[4] = 26;
  824. NTConfig_AttackSkill[5] = 26;
  825. NTConfig_AttackSkill[6] = 26;
  826. NTConfig_AttackSkill[7] = 22;
  827. break;
  828. }
  829.  
  830. return (NTConfig_AttackSkill[1] && NTConfig_AttackSkill[3]);
  831. }
  832.  
  833.  
  834. function NTA_AmazonAttackInt(target, firstorder)
  835. {
  836. var _primaryindex;
  837.  
  838. if(NTTMGR_CheckCurse(NTConfig_CheckSelfSafe&0x10, NTConfig_CheckMercSafe&0x10))
  839. {
  840. if(!NTTMGR_VisitTown())
  841. return 0;
  842. }
  843.  
  844.  
  845. if(me.GetSkill(12, false) > 1)
  846. NTA_HaveArrows();
  847. else
  848. NTA_IsWeaponBroken();
  849.  
  850.  
  851. if(firstorder && NTConfig_AttackSkill[0] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[0]) < 100)
  852. {
  853. if(GetDistance(me, target) > _NTA_SkillRange[0] || !CheckCollision(me, target, 4))
  854. {
  855. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[0], 4);
  856.  
  857. if(_pos)
  858. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  859. }
  860.  
  861. if(!NTC_CastSkill(NTConfig_AttackSkill[0], _NTA_SkillHand[0], target))
  862. return 2;
  863.  
  864. return 3;
  865. }
  866.  
  867. _primaryindex = (target.spectype&0x0A) ? 1 : 3;
  868.  
  869. switch(target.classid)
  870. {
  871. case 243://Diablo
  872. case 544://Baal
  873. case 242:
  874. if(!NTA_AmazonCastSkillInt(7, target))
  875. return 2;
  876.  
  877. return 3;
  878. default:
  879. break;
  880. }
  881.  
  882. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) <= 90)
  883. {
  884. if(!NTA_AmazonCastSkillInt(_primaryindex, target))
  885. return 2;
  886.  
  887. return 3;
  888. }
  889.  
  890.  
  891. if(NTConfig_AttackSkill[5] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[5]) > 80)
  892. {
  893. if(!NTA_AmazonCastSkillInt(5, target))
  894. return 2;
  895.  
  896. return 3;
  897. }
  898.  
  899. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) < 100 || (_primaryindex == 1 && NTC_GetMerc()))
  900. {
  901. if(!NTA_AmazonCastSkillInt(_primaryindex, target))
  902. return 2;
  903.  
  904. return 3;
  905. }
  906.  
  907. return 1;
  908. }
  909.  
  910. function NTA_AmazonCastSkillInt(index, target)
  911. {
  912.  
  913. if(GetDistance(me, target) > _NTA_SkillRange[index] || !CheckCollision(me, target, 4))
  914. {
  915. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index], 4);
  916.  
  917. if(_pos)
  918. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  919. }
  920.  
  921. return NTC_CastSkill(NTConfig_AttackSkill[index], NTC_HAND_LEFT, target);
  922.  
  923. if(NTConfig_AttackSkill[index+1] > 0)
  924. {
  925. if(GetDistance(me, target) > _NTA_SkillRange[index+1] || !CheckCollision(me, target, 4))
  926. {
  927. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index+1], 4);
  928.  
  929. if(_pos)
  930. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  931. }
  932.  
  933. return NTC_CastSkill(NTConfig_AttackSkill[index+1], _NTA_SkillHand[index+1], target);
  934. }
  935.  
  936. }
  937. function NTA_SorceressAttackPatternInt()
  938. {
  939. var _maxindex, _maxskill;
  940. var _avgskilllevel = new Array();
  941.  
  942. _avgskilllevel[0] = parseInt((me.GetSkill(59, false)+me.GetSkill(39, false)+me.GetSkill(45, false)+me.GetSkill(55, false))/4);
  943. _avgskilllevel[1] = parseInt((me.GetSkill(53, false)+me.GetSkill(38, false)+me.GetSkill(48, false)+me.GetSkill(49, false))/4);
  944. _avgskilllevel[2] = parseInt((me.GetSkill(47, false)+me.GetSkill(36, false)+me.GetSkill(56, false)+me.GetSkill(64, false))/4);
  945. _avgskilllevel[3] = parseInt((me.GetSkill(47, false)+me.GetSkill(36, false)+me.GetSkill(56, false))/3);
  946.  
  947. _maxindex = -1;
  948. _maxskill = 0;
  949.  
  950. for(var i = 0 ; i < _avgskilllevel.length ; i++)
  951. {
  952. if(_avgskilllevel[i] > _maxskill)
  953. {
  954. _maxindex = i;
  955. _maxskill = _avgskilllevel[i];
  956. }
  957. }
  958.  
  959. switch(_maxindex)
  960. {
  961. case 0: // Blizzard + Glacial Spike
  962. NTConfig_AttackSkill[1] = 59;
  963. NTConfig_AttackSkill[2] = 55;
  964. NTConfig_AttackSkill[3] = 59;
  965. NTConfig_AttackSkill[4] = 55;
  966. break;
  967. case 1: // Chain Lightning + Lightning
  968. NTConfig_AttackSkill[1] = 49;
  969. NTConfig_AttackSkill[3] = 53;
  970. break;
  971. case 2: // Fire Ball + Frozen Orb
  972. NTConfig_AttackSkill[0] = 64;
  973. NTConfig_AttackSkill[1] = 47;
  974. NTConfig_AttackSkill[3] = 47;
  975. NTConfig_AttackSkill[5] = 64;
  976. NTConfig_AttackSkill[6] = 55;
  977. break;
  978. case 3: // Fire Ball + Meteor
  979. NTConfig_AttackSkill[1] = 56;
  980. NTConfig_AttackSkill[2] = 47;
  981. NTConfig_AttackSkill[3] = 56;
  982. NTConfig_AttackSkill[4] = 47;
  983. break;
  984. }
  985.  
  986. return (NTConfig_AttackSkill[1] && NTConfig_AttackSkill[3]);
  987. }
  988.  
  989. function NTA_SorceressAttackInt(target, firstorder)
  990. {
  991. var _primaryindex;
  992.  
  993. if(NTTMGR_CheckCurse(NTConfig_CheckSelfSafe&0x10, NTConfig_CheckMercSafe&0x10))
  994. {
  995. if(!NTTMGR_VisitTown())
  996. return 0;
  997. }
  998.  
  999. if(firstorder && NTConfig_AttackSkill[0] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[0]) < 100 && me.GetSkillStatus(NTConfig_AttackSkill[0]) != 8)
  1000. {
  1001. if(GetDistance(me, target) > _NTA_SkillRange[0] || !CheckCollision(me, target, 4))
  1002. {
  1003. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[0], 4);
  1004.  
  1005. if(_pos)
  1006. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1007. }
  1008.  
  1009. if(!NTC_CastSkill(NTConfig_AttackSkill[0], _NTA_SkillHand[0], target))
  1010. return 2;
  1011.  
  1012. return 3;
  1013. }
  1014.  
  1015. if(NTConfig_CastStatic < 100 && parseInt(target.hp*100/target.hpmax) > NTConfig_CastStatic && NTA_GetResistance(target, NTA_DAMAGE_LIGHTNING) <= 80)
  1016. {
  1017. var _staticlevel = NTC_GetSkillLevel(42);
  1018.  
  1019. if(_staticlevel > 0)
  1020. {
  1021. var _staticrange;
  1022. var _castx, _casty;
  1023.  
  1024. _staticrange = Math.floor((5+_staticlevel-1)*2/3);
  1025.  
  1026. if(GetDistance(me, target) > _staticrange || !CheckCollision(me, target, 6))
  1027. {
  1028. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _staticrange, 6);
  1029.  
  1030. if(_pos)
  1031. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1032. }
  1033.  
  1034. if(target.x < me.x)
  1035. _castx = me.x - 1;
  1036. else if(target.x > me.x)
  1037. _castx = me.x + 1;
  1038. else
  1039. _castx = me.x;
  1040.  
  1041. if(target.y < me.y)
  1042. _casty = me.y - 1;
  1043. else if(target.y > me.y)
  1044. _casty = me.y + 1;
  1045. else
  1046. _casty = me.y;
  1047.  
  1048. if(!CheckCollision(target.areaid, _castx, _casty, 1))
  1049. {
  1050. _castx = me.x;
  1051. _casty = me.y;
  1052. }
  1053.  
  1054. if(!NTC_CastSkill(42, NTC_HAND_RIGHT, _castx, _casty))
  1055. return 2;
  1056.  
  1057. return 3;
  1058. }
  1059. }
  1060.  
  1061. _primaryindex = (target.spectype&0x0A) ? 1 : 3;
  1062.  
  1063. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) <= 90)
  1064. {
  1065. if(!NTA_SorceressCastSkillInt(_primaryindex, target))
  1066. return 2;
  1067.  
  1068. return 3;
  1069. }
  1070.  
  1071. if(NTConfig_AttackSkill[5] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[5]) <= 80)
  1072. {
  1073. if(!NTA_SorceressCastSkillInt(5, target))
  1074. return 2;
  1075.  
  1076. return 3;
  1077. }
  1078.  
  1079. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) < 100 || (_primaryindex == 1 && NTC_GetMerc()))
  1080. {
  1081. if(!NTA_SorceressCastSkillInt(_primaryindex, target))
  1082. return 2;
  1083.  
  1084. return 3;
  1085. }
  1086.  
  1087. return 1;
  1088. }
  1089.  
  1090. function NTA_SorceressCastSkillInt(index, target)
  1091. {
  1092. if(me.GetSkillStatus(NTConfig_AttackSkill[index]) != 8)
  1093. {
  1094. if(GetDistance(me, target) > _NTA_SkillRange[index] || !CheckCollision(me, target, 4))
  1095. {
  1096. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index], 4);
  1097.  
  1098. if(_pos)
  1099. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1100. }
  1101.  
  1102. return NTC_CastSkill(NTConfig_AttackSkill[index], _NTA_SkillHand[index], target);
  1103. }
  1104.  
  1105. if(NTConfig_AttackSkill[index+1] > 0)
  1106. {
  1107. if(GetDistance(me, target) > _NTA_SkillRange[index+1] || !CheckCollision(me, target, 4))
  1108. {
  1109. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index+1], 4);
  1110.  
  1111. if(_pos)
  1112. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1113. }
  1114.  
  1115. return NTC_CastSkill(NTConfig_AttackSkill[index+1], _NTA_SkillHand[index+1], target);
  1116. }
  1117.  
  1118. for(var i = 0 ; i < 25 ; i++)
  1119. {
  1120. NTC_Delay(NTC_DELAY_FRAME);
  1121.  
  1122. if(me.GetSkillStatus(NTConfig_AttackSkill[index]) != 8)
  1123. break;
  1124. }
  1125.  
  1126. return false;
  1127. }
  1128.  
  1129. function NTA_NecromancerAttackPatternInt()
  1130. {
  1131. return false;
  1132. }
  1133.  
  1134. function NTA_NecromancerAttackInt(target, firstorder)
  1135. {
  1136. return 1;
  1137. }
  1138.  
  1139. function NTA_NecromancerCastSkillInt(index, target)
  1140. {
  1141. return false;
  1142. }
  1143.  
  1144. function NTA_PaladinAttackPatternInt()
  1145. {
  1146. var _maxindex, _maxskill;
  1147. var _avgskilllevel = new Array();
  1148.  
  1149. _avgskilllevel[0] = parseInt((me.GetSkill(112, false)+me.GetSkill(108, false)+me.GetSkill(115, false))/3);
  1150. _avgskilllevel[1] = parseInt((me.GetSkill(106, false)+me.GetSkill(96, false))/2);
  1151. _avgskilllevel[2] = parseInt((me.GetSkill(121, false)+me.GetSkill(101, false)+me.GetSkill(118, false))/3);
  1152.  
  1153. _maxindex = -1;
  1154. _maxskill = 0;
  1155.  
  1156. for(var i = 0 ; i < _avgskilllevel.length ; i++)
  1157. {
  1158. if(_avgskilllevel[i] > _maxskill)
  1159. {
  1160. _maxindex = i;
  1161. _maxskill = _avgskilllevel[i];
  1162. }
  1163. }
  1164.  
  1165. switch(_maxindex)
  1166. {
  1167. case 0: // Blessed Hammer
  1168. NTConfig_AttackSkill[1] = 112;
  1169. NTConfig_AttackSkill[2] = 113;
  1170. NTConfig_AttackSkill[3] = 112;
  1171. NTConfig_AttackSkill[4] = 113;
  1172. break;
  1173. case 1: // Zeal
  1174. NTConfig_AttackSkill[1] = 106;
  1175. NTConfig_AttackSkill[2] = 122;
  1176. NTConfig_AttackSkill[3] = 106;
  1177. NTConfig_AttackSkill[4] = 122;
  1178. break;
  1179. case 2: // Fist of the Heavens
  1180. NTConfig_AttackSkill[1] = 121;
  1181. NTConfig_AttackSkill[2] = 123;
  1182. NTConfig_AttackSkill[3] = 121;
  1183. NTConfig_AttackSkill[4] = 123;
  1184. break;
  1185. }
  1186.  
  1187. return (NTConfig_AttackSkill[1] && NTConfig_AttackSkill[3]);
  1188. }
  1189.  
  1190. function NTA_PaladinAttackInt(target, firstorder)
  1191. {
  1192. var _primaryindex;
  1193.  
  1194. if(NTTMGR_CheckCurse(NTConfig_CheckSelfSafe&0x10, NTConfig_CheckMercSafe&0x10))
  1195. {
  1196. if(!NTTMGR_VisitTown())
  1197. return 0;
  1198. }
  1199.  
  1200. if(firstorder && NTConfig_AttackSkill[0] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[0]) < 100)
  1201. {
  1202. if(GetDistance(me, target) > _NTA_SkillRange[0] || !CheckCollision(me, target, 4))
  1203. {
  1204. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[0], 4);
  1205.  
  1206. if(_pos)
  1207. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1208. }
  1209.  
  1210. if(!NTC_CastSkill(NTConfig_AttackSkill[0], _NTA_SkillHand[0], target))
  1211. return 2;
  1212.  
  1213. return 3;
  1214. }
  1215.  
  1216. _primaryindex = (target.spectype&0x0A) ? 1 : 3;
  1217.  
  1218. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) < 100)
  1219. {
  1220. if(_NTA_SkillRange[_primaryindex] < 4 && !CheckCollision(target.areaid, target.x, target.y, 1))
  1221. return 1;
  1222.  
  1223. if(!NTA_PaladinCastSkillInt(_primaryindex, target))
  1224. return 2;
  1225.  
  1226. return 3;
  1227. }
  1228.  
  1229. if(NTConfig_AttackSkill[5] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[5]) < 100)
  1230. {
  1231. if(_NTA_SkillRange[5] < 4 && !CheckCollision(target.areaid, target.x, target.y, 1))
  1232. return 1;
  1233.  
  1234. if(!NTA_PaladinCastSkillInt(5, target))
  1235. return 2;
  1236.  
  1237. return 3;
  1238. }
  1239.  
  1240. return 1;
  1241. }
  1242.  
  1243. function NTA_PaladinCastSkillInt(index, target)
  1244. {
  1245. if(NTConfig_AttackSkill[index] == 112)
  1246. {
  1247. if(me.x-target.x < 1 || me.x-target.x > 2 || me.y-target.y < 1 || me.y-target.y > 2)
  1248. {
  1249. if(CheckCollision(target.areaid, target.x+2, target.y+2, 1))
  1250. NTM_MoveTo(target.areaid, target.x+2, target.y+2, 0);
  1251. else if(me.x-target.x < -4 || me.x-target.x > 2 || me.y-target.y < 0 || me.y-target.y > 2)
  1252. NTM_MoveTo(target.areaid, target.x-4, target.y, 0);
  1253. }
  1254. }
  1255. else
  1256. {
  1257. if(GetDistance(me, target) > _NTA_SkillRange[index] || !CheckCollision(me, target, 4))
  1258. {
  1259. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index], 4);
  1260.  
  1261. if(_pos)
  1262. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1263. }
  1264. }
  1265.  
  1266. if(NTConfig_AttackSkill[index+1] > 0)
  1267. NTC_PutSkill(NTConfig_AttackSkill[index+1], NTC_HAND_RIGHT);
  1268.  
  1269. return NTC_CastSkill(NTConfig_AttackSkill[index], _NTA_SkillHand[index], target);
  1270. }
  1271.  
  1272. function NTA_BarbarianAttackPatternInt()
  1273. {
  1274. var _maxindex, _maxskill;
  1275. var _avgskilllevel = new Array();
  1276.  
  1277. _avgskilllevel[0] = me.GetSkill(151, false);
  1278.  
  1279. _maxindex = -1;
  1280. _maxskill = 0;
  1281.  
  1282. for(var i = 0 ; i < _avgskilllevel.length ; i++)
  1283. {
  1284. if(_avgskilllevel[i] > _maxskill)
  1285. {
  1286. _maxindex = i;
  1287. _maxskill = _avgskilllevel[i];
  1288. }
  1289. }
  1290.  
  1291. switch(_maxindex)
  1292. {
  1293. case 0: // Whirlwind
  1294. NTConfig_AttackSkill[1] = 151;
  1295. NTConfig_AttackSkill[3] = 151;
  1296. NTConfig_AttackSkill[5] = 152;
  1297. break;
  1298. }
  1299.  
  1300. return (NTConfig_AttackSkill[1] && NTConfig_AttackSkill[3]);
  1301. }
  1302.  
  1303. function NTA_BarbarianAttackInt(target, firstorder)
  1304. {
  1305. var _primaryindex;
  1306.  
  1307. if(NTTMGR_CheckCurse(NTConfig_CheckSelfSafe&0x10, NTConfig_CheckMercSafe&0x10))
  1308. {
  1309. if(!NTTMGR_VisitTown())
  1310. return 0;
  1311. }
  1312.  
  1313. if(firstorder && NTConfig_AttackSkill[0] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[0]) < 100)
  1314. {
  1315. if(GetDistance(me, target) > _NTA_SkillRange[0] || !CheckCollision(me, target, 4))
  1316. {
  1317. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[0], 4);
  1318.  
  1319. if(_pos)
  1320. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1321. }
  1322.  
  1323. if(!NTC_CastSkill(NTConfig_AttackSkill[0], _NTA_SkillHand[0], target))
  1324. return 2;
  1325.  
  1326. return 3;
  1327. }
  1328.  
  1329. _primaryindex = (target.spectype&0x0A) ? 1 : 3;
  1330.  
  1331. if(NTA_GetResistance(target, _NTA_SkillDamage[_primaryindex]) < 100)
  1332. {
  1333. if((_NTA_SkillRange[_primaryindex] < 4 || NTConfig_AttackSkill[_primaryindex] == 151) && !CheckCollision(target.areaid, target.x, target.y, 1))
  1334. return 1;
  1335.  
  1336. if(!NTA_BarbarianCastSkillInt(_primaryindex, target))
  1337. return 2;
  1338.  
  1339. return 3;
  1340. }
  1341.  
  1342. if(NTConfig_AttackSkill[5] > 0 && NTA_GetResistance(target, _NTA_SkillDamage[5]) < 100)
  1343. {
  1344. if((_NTA_SkillRange[5] < 4 || NTConfig_AttackSkill[5] == 151) && !CheckCollision(target.areaid, target.x, target.y, 1))
  1345. return 1;
  1346.  
  1347. if(!NTA_BarbarianCastSkillInt(5, target))
  1348. return 2;
  1349.  
  1350. return 3;
  1351. }
  1352.  
  1353. return 1;
  1354. }
  1355.  
  1356. function NTA_BarbarianCastSkillInt(index, target)
  1357. {
  1358. if(NTConfig_AttackSkill[index] == 151)
  1359. {
  1360. var _castx, _casty;
  1361.  
  1362. if(GetDistance(me, target) > _NTA_SkillRange[index] || !CheckCollision(me, target, 5))
  1363. {
  1364. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index], 5);
  1365.  
  1366. if(_pos)
  1367. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1368. }
  1369.  
  1370. _castx = target.x > me.x ? target.x+3 : target.x-3;
  1371. _casty = target.y > me.y ? target.y+3 : target.y-3;
  1372.  
  1373. return NTC_CastSkill(NTConfig_AttackSkill[index], _NTA_SkillHand[index], _castx, _casty);
  1374. }
  1375.  
  1376. if(GetDistance(me, target) > _NTA_SkillRange[index] || !CheckCollision(me, target, 4))
  1377. {
  1378. var _pos = me.GetOptimalAttackPos(target.areaid, target.x, target.y, _NTA_SkillRange[index], 4);
  1379.  
  1380. if(_pos)
  1381. NTM_MoveTo(target.areaid, _pos[0], _pos[1], 0);
  1382. }
  1383.  
  1384. return NTC_CastSkill(NTConfig_AttackSkill[index], _NTA_SkillHand[index], target);
  1385. }
  1386.  
  1387. function NTA_DruidAttackPatternInt()
  1388. {
  1389. return false;
  1390. }
  1391.  
  1392. function NTA_DruidAttackInt(target, firstorder)
  1393. {
  1394. return 1;
  1395. }
  1396.  
  1397. function NTA_DruidCastSkillInt(index, target)
  1398. {
  1399. return false;
  1400. }
  1401.  
  1402. function NTA_AssassinAttackPatternInt()
  1403. {
  1404. return false;
  1405. }
  1406.  
  1407. function NTA_AssassinAttackInt(target, firstorder)
  1408. {
  1409. return 1;
  1410. }
  1411.  
  1412. function NTA_AssassinCastSkillInt(index, target)
  1413. {
  1414. return false;
  1415. }
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!