API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 28th, 2017
58
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.21 KB | None | 0 0
raw download clone embed print report
  1. var NTM_AreaWPArray = [
  2. 0, 0x01, 0, 0x03, 0x04, 0x05, 0x06, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0..15
  3. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1b, 0, 0x1d, 0, 0, // 16..31
  4. 0x20, 0, 0, 0x23, 0, 0, 0, 0, 0x28, 0, 0x2a, 0x2b, 0x2c, 0, 0x2e, 0, // 32..47
  5. 0x30, 0, 0, 0, 0x34, 0, 0, 0, 0, 0x39, 0, 0, 0, 0, 0, 0, // 48..63
  6. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, // 64..79
  7. 0x50, 0x51, 0, 0x53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80..95
  8. 0, 0, 0, 0, 0, 0x65, 0, 0x67, 0, 0, 0x6a, 0x6b, 0, 0x6d, 0, 0x6f, // 96..111
  9. 0x70, 0x71, 0, 0x73, 0, 0x75, 0x76, 0, 0, 0, 0, 0x7b, 0, 0, 0, 0, // 112..127
  10. 0, 0x81, 0, 0, 0]; // 128..132
  11.  
  12. var NTM_Waypoints = [
  13. 0x01, 0x03, 0x04, 0x05, 0x06, 0x1b, 0x1d, 0x20, 0x23, // 0 ..8 act1
  14. 0x28, 0x30, 0x2a, 0x39, 0x2b, 0x2c, 0x34, 0x4a, 0x2e, // 9 ..17 act2
  15. 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x53, 0x65, // 18..26 act3
  16. 0x67, 0x6a, 0x6b, // 27..29 act4
  17. 0x6d, 0x6f, 0x70, 0x71, 0x73, 0x7b, 0x75, 0x76, 0x81]; // 30..38 act5
  18. var usedWp = false;
  19.  
  20. function NTM_MoveTo(x, y, retry, clearpath)
  21. {
  22. debugPrint("ntm moveto x:"+x+" y:"+y );
  23. var tempAction = currentAction;
  24. var _walk;
  25. var _path;
  26. var _result;
  27. var _retry = 0;
  28.  
  29. if(!NTC_WaitCastDone())
  30. return false;
  31.  
  32. if(x == me.x && y == me.y)
  33. return true;
  34.  
  35. if(arguments.length < 3)
  36. retry = 3;
  37.  
  38. if(arguments.length < 4)
  39. clearpath = false;
  40.  
  41. if(NTC_InTown() || NTC_CheckSkill(54) < 1)
  42. _walk = true;
  43. else
  44. _walk = false;
  45.  
  46. if (!_walk && getDistance(me.x,me.y,x,y)<30) //optimzation By Fr3DBr
  47. return NTM_TeleportTo(x, y);
  48. debugPrint("getpath("+me.area+", "+me.x+", "+me.y+", "+x+", "+y+", "+!_walk+")");
  49. if (_walk)
  50. _path = getPath(getArea(me.area), me.x, me.y, x, y,!_walk);
  51. //_path = getPath(me.area, me.x, me.y, x, y,!_walk);
  52. else
  53. _path = getPath(getArea(me.area), me.x, me.y, x, y,!_walk,40);
  54. //_path = getPath(me.area, me.x, me.y, x, y,!_walk,40);
  55. debugPrint ("path.toSource "+_path.toSource());
  56. if(!_path && !_walk) //tele path failed trying walking path
  57. _path = getPath(getArea(me.area), me.x, me.y, x, y,_walk,40);
  58. //_path = getPath(me.area, me.x, me.y, x, y,_walk,40);
  59.  
  60. if(!_path)
  61. {
  62. print("getpath("+me.area+","+me.x+","+me.y+","+x+","+y+","+!_walk+") failed");
  63. return false;
  64. }
  65.  
  66. for(var i = 0 ; i < _path.length ; i++)
  67. {
  68. if (tempAction != currentAction) {
  69. print("breaking Out of Moveto");
  70. return false;
  71. }
  72. if(_walk)
  73. //_result = NTM_WalkTo(_path[i][0], _path[i][1]);
  74. _result = NTM_WalkTo(_path[i].x, _path[i].y);
  75. else
  76. //_result = NTM_TeleportTo(_path[i][0], _path[i][1]);
  77. _result = NTM_TeleportTo(_path[i].x, _path[i].y);
  78.  
  79. if(_result)
  80. {
  81. if(clearpath)
  82. {
  83. NTA_ClearPosition(25, 0x04);
  84. NTA_ClearPosition(25);
  85. NTSI_PickItems();
  86. NTT_CleanPotions();
  87.  
  88. //NTM_MoveTo(_path[i][0], _path[i][1], 2);
  89. NTM_MoveTo(_path[i].x, _path[i].y, 2);
  90. }
  91. }
  92. else
  93. {
  94. if(_retry++ < retry)
  95. {
  96. if(_walk)
  97. _path = getPath(getArea(me.area), me.x, me.y, x, y, _walk);
  98. else
  99. _path = getPath(getArea(me.area), me.x, me.y, x, y, !_walk, 40);
  100. //_path = getPath(me.area, me.x, me.y, x, y);
  101.  
  102. if(!_path)
  103. {
  104. print("getpath2("+me.area+","+me.x+","+me.y+","+x+","+y+","+!_walk+") failed");
  105. return false;
  106. }
  107.  
  108. i = -1;
  109. }
  110. else
  111. return false;
  112. }
  113. }
  114.  
  115. return true;
  116. }
  117.  
  118.  
  119. function NTM_MoveToObject(unittype, low, high, offsetx, offsety, clearpath)
  120. {
  121. debugPrint("ntm movetoObject" );
  122.  
  123. var _unit;
  124.  
  125. if(arguments.length < 3)
  126. high = low;
  127.  
  128. if(arguments.length < 4)
  129. {
  130. offsetx = 0;
  131. offsety = 0;
  132. }
  133.  
  134. if(arguments.length < 6)
  135. clearpath = false;
  136.  
  137. _unit = NTC_GetPresetUnits(unittype);
  138.  
  139. if(!_unit)
  140. {
  141. print("cant find unit");
  142. debugPrint("ntm cant find presets" );
  143. return false;
  144.  
  145. }
  146.  
  147. debugPrint("ntm getpresets len:"+_unit.length );
  148.  
  149. for(var i = 0 ; i < _unit.length ; i++)
  150. {
  151.  
  152. if(_unit[i].id >= low && _unit[i].id <= high)
  153. {
  154. return NTM_MoveTo(_unit[i].roomx*5+_unit[i].x+offsetx, _unit[i].roomy*5+_unit[i].y+offsety, 3, clearpath);
  155. }
  156. }
  157. print("Failed to find PresetUnit");
  158. return false;
  159. }
  160.  
  161. function NTM_TeleportTo(x, y)
  162. {
  163. debugPrint("ntm teleportto X:"+x+" Y: "+y );
  164.  
  165. var _destx, _desty;
  166.  
  167. _destx = x;
  168. _desty = y;
  169.  
  170. for(var i = 0 ; i < 20 ; i++)
  171. {
  172. if((i % 10) == 0)
  173. {
  174. if(i > 0)
  175. {
  176. _destx = x + rnd(-2, 2);
  177. _desty = y + rnd(-2, 2);
  178. }
  179.  
  180. NTC_DoCast(54, NTC_HAND_RIGHT, _destx, _desty);
  181. }
  182.  
  183. NTC_Delay(25);
  184.  
  185. if(Math.abs(me.x-_destx) < 4 && Math.abs(me.y-_desty) < 4)
  186. return true;
  187. }
  188.  
  189. return false;
  190. }
  191.  
  192. function NTM_WalkTo(x, y)
  193. {
  194. debugPrint("ntm walkTo" );
  195. var _startx, _starty;
  196. var _currdestx, _currdesty;
  197. var _thrash = 0;
  198.  
  199. if(Math.abs(me.x-x) < 2 && Math.abs(me.y-y) < 2)
  200. return true;
  201.  
  202. if(me.runwalk == 0)
  203. me.runwalk = 1;
  204.  
  205. _startx = me.x;
  206. _starty = me.y;
  207. _currdestx = x;
  208. _currdesty = y;
  209.  
  210. for(var i = 0 ; i < 250 ; i++)
  211. {
  212. if((Math.abs(me.x-x) > 4 || Math.abs(me.y-y) > 4) && me.mode != 17)
  213. {
  214. _currdestx += rnd(-2, 2);
  215. _currdesty += rnd(-2, 2);
  216.  
  217. NTC_DoClick(NTC_CLICK_LDOWN, NTC_SHIFT_NONE, _currdestx, _currdesty);
  218.  
  219. NTC_Delay(NTC_DELAY_FRAME);
  220.  
  221. if(Math.abs(me.x-_startx) < 2 && Math.abs(me.y-_starty) < 2)
  222. {
  223. if(_thrash >= 75)
  224. {
  225. var a = Math.atan2(_currdestx-_startx, _currdesty-_starty);
  226. a = Math.floor(a*100) + 157; // + pi/2;
  227. var direction = rnd(a, a+314)/100; // + pi
  228. _currdestx = Math.floor(Math.sin(direction)*20) + me.x;
  229. _currdesty = Math.floor(Math.cos(direction)*20) + me.y;
  230.  
  231. _thrash = 0;
  232. }
  233. else
  234. _thrash++;
  235. }
  236. else
  237. {
  238. _startx = me.x;
  239. _starty = me.y;
  240. _currdestx = x;
  241. _currdesty = y;
  242. }
  243. }
  244. else
  245. break;
  246. }
  247.  
  248. if(Math.abs(me.x-x) > 4 || Math.abs(me.y-y) > 4)
  249. return false;
  250.  
  251. return true;
  252. }
  253.  
  254. function NTM_TakeStairs(low, high, area)
  255. {
  256. debugPrint("ntm takeStairs low:"+low+" High:"+high+" area:"+area );
  257. var _unit;
  258. var _prearea;
  259.  
  260. if(arguments.length < 3)
  261. area = me.area;
  262.  
  263. if(arguments.length < 2)
  264. _unit = NTC_GetUnit(NTC_UNIT_OBJECT, low);
  265. else
  266. _unit = NTM_GetStairsInt(low, high, area);
  267.  
  268. if(!_unit){
  269. debugPrint("ntm takeStairs Failed: low:"+low+" High:"+high+" area:"+area );
  270. return false;
  271. }
  272. _prearea = me.area;
  273.  
  274. for(var i = 0 ; i < 100 ; i++)
  275. {
  276. if((i % 25) == 0)
  277. {
  278. if(NTM_GetCloserInt(_unit))
  279. _unit.interact();
  280. }
  281.  
  282. NTC_Delay(NTC_DELAY_FRAME);
  283.  
  284. if(me.area != _prearea)
  285. break;
  286. }
  287. preWalkDelay();
  288.  
  289. while(me.area == 0)
  290. NTC_Delay(NTC_DELAY_FRAME);
  291.  
  292. if(me.area == _prearea)
  293. return false;
  294.  
  295. //NTC_PingDelay(NTConfig_AreaDelay);
  296. debugPrint("ntm takeStairsDelay" );
  297. postWalkDelay();
  298. delay(50);
  299. return true;
  300. }
  301. function postWalkDelay(){
  302. debugPrint("ntm postWalkDelay" );
  303. while (me.mode == 2 || me.mode == 6){
  304. delay(40);
  305. debugPrint("ntm takeStairsDelay walking" );
  306. }
  307. delay(200);
  308. me.cancel(0);
  309. sendCopyData(null, "OOG", 0,"Info "+NTAR_Areas[me.area]);
  310. }
  311. function preWalkDelay(){
  312. var pwTimeouts =0;
  313. debugPrint("preWalkDelay" );
  314. while ((!(me.mode == 2 || me.mode == 6)) && (pwTimeouts < 10)){
  315. delay(40);
  316. pwTimeouts = pwTimeouts +1;
  317.  
  318. debugPrint("ntm Prewalking delay"+pwTimeouts );
  319. }
  320.  
  321. }
  322. function NTM_UsePortal(how, dest, ownername, portal)
  323. {
  324. debugPrint("ntm usePortal" );
  325. if(me.area == dest)
  326. return true;
  327.  
  328. if(NTC_InTown())
  329. NTT_MenuCancel();
  330.  
  331. var _errorcode = NTM_ChangeAreaInt(how, dest, ownername, portal);
  332.  
  333. if(_errorcode > 0)
  334. {
  335. delay(400);
  336. return true;
  337. }
  338. //if (_errorcode==-1)
  339. //print("correct portal not found");
  340. //else
  341. if (_errorcode!=-1)
  342. print("errorcode "+_errorcode);
  343. return false;
  344. }
  345.  
  346. function NTM_MakeTP(dest)
  347. {
  348. debugPrint("makeTp" );
  349. var _usetp = true;
  350. var _portal;
  351.  
  352. if(NTC_InTown())
  353. return true;
  354.  
  355. if(arguments.length < 1)
  356. _usetp = false;
  357.  
  358. if(!NTC_DoCast(220, NTC_HAND_RIGHT))
  359. return false;
  360.  
  361. NTC_PingDelay(250);
  362.  
  363. for(var i = 0 ; i < 12 ; i++)
  364. {
  365. _portal = NTC_GetUnit(NTC_UNIT_OBJECT, "Portal");
  366.  
  367. if(_portal)
  368. {
  369. do
  370. {
  371. if(_portal.type == NTC_UNIT_OBJECT && _portal.mode == 2 && NTC_CheckOwner(_portal))
  372. {
  373. if(_usetp)
  374. return NTM_UsePortal("BluePortal", dest, me.name, copyUnit(_portal));
  375.  
  376. return true;
  377. }
  378. } while(_portal.getNext());
  379. }
  380.  
  381. NTC_Delay(250);
  382. }
  383.  
  384. return false;
  385. }
  386.  
  387. // Internal function
  388. function NTM_ChangeAreaInt(how, dest, ownername, myportal)
  389. {
  390. debugPrint("ntm changeAreaint how:"+how+" Dest:"+dest );
  391. var _portal, _wpHex;
  392. var _playerportal = false;
  393. var _prearea;
  394. var _warpstart;
  395. me.cancel(0);
  396. if(how == "BluePortal")
  397. {
  398. if(!ownername)
  399. ownername = me.name;
  400.  
  401. how = "Portal";
  402. _playerportal = true;
  403. }
  404.  
  405. if(arguments.length > 3 && myportal)
  406. _portal = copyUnit(myportal);
  407. else if(how == "Portal")
  408. {
  409. _portal = NTM_FindCorrectPortalInt(_playerportal, ownername);
  410.  
  411. if(_portal < 0)
  412. _portal = NTM_FindPortalAreaInt(dest);
  413.  
  414. if(_portal == -1)
  415. return -1;
  416. }
  417. else
  418. {
  419. _wpHex = NTM_AreaWPArray[dest];
  420.  
  421. if(!_wpHex)
  422. return -4;
  423.  
  424. _portal = NTC_GetUnit(NTC_UNIT_OBJECT, how);
  425. }
  426.  
  427. if(!_portal)
  428. return -1;
  429.  
  430. _prearea = me.area;
  431. _warpstart = getTickCount();
  432.  
  433. if(how == "Waypoint")
  434. {
  435. var i;
  436.  
  437. for(i = 0 ; i < 50 ; i++)
  438. {
  439. if((i % 25) == 0)
  440. _portal.interact();
  441.  
  442. NTC_Delay(NTC_DELAY_FRAME);
  443.  
  444. if(getUIFlag(0x14))
  445. {
  446. NTC_PingDelay(500);
  447. break;
  448. }else{
  449. NTM_GetCloserInt(_portal);
  450. }
  451. }
  452.  
  453. if(i >= 50 || !NTM_CheckWPInt(_wpHex))
  454. {
  455. print("checkwaypoint failed "+_wpHex+" getUIFlag(0x14)="+getUIFlag(0x14) +" ping "+ me.ping);
  456. me.cancel(0);
  457. return -5;
  458. }
  459. _portal.interact(_wpHex);
  460. /*
  461. for(i = 0 ; i < 200 ; i++)
  462. {
  463. if((i % 25) == 0)
  464. {
  465. if(NTM_GetCloserInt(_portal))
  466. _portal.interact(_wpHex);
  467. }
  468.  
  469. NTC_Delay(NTC_DELAY_FRAME);
  470.  
  471. if(me.area != _prearea)
  472. break;
  473. if(i >= 150 && !NTM_CheckWPInt(_wpHex))
  474. {
  475. me.cancel(0);
  476. print("Waypoint not Found! area:"+dest );
  477. return -5;
  478. }
  479. }
  480. */
  481. preWalkDelay();
  482. }
  483.  
  484. else
  485. {
  486. for(var i = 0 ; i < 100 ; i++)
  487. {
  488. if((i % 25) == 0)
  489. {
  490. if(NTM_GetCloserInt(_portal))
  491. _portal.interact();
  492. }
  493.  
  494. NTC_Delay(NTC_DELAY_FRAME);
  495.  
  496. if(me.area != _prearea)
  497. break;
  498. }
  499. preWalkDelay();
  500. }
  501.  
  502. while(me.area == 0){
  503. debugPrint("ntm getstairsint area is 0 delay" );
  504. NTC_Delay(NTC_DELAY_FRAME);
  505. }
  506.  
  507. if(how == "Waypoint")
  508. {
  509. while(getUIFlag(0x14))
  510. {
  511. me.cancel(0);
  512. NTC_Delay(100);
  513. }
  514. }
  515.  
  516. postWalkDelay();
  517. if(how == "Waypoint"){
  518. var timeout = 0
  519. while(me.area != dest)
  520. {
  521. NTC_Delay(100);
  522. timeout ++;
  523. if (timeout >200){
  524. print("extra delay failed me.area :"+me.area+" dest "+dest );
  525. return -7;
  526. }
  527. }
  528. }
  529. if(me.area != dest)
  530. return -7;
  531.  
  532. delay(50);
  533. return 1;
  534. }
  535.  
  536. function NTM_GetStairsInt(lo, hi, area)
  537. {
  538. debugPrint("ntm getstairsint" );
  539. var _tile = NTC_GetUnit(NTC_UNIT_TILE);
  540.  
  541. if(_tile)
  542. {
  543. do
  544. {
  545. if(_tile.type == NTC_UNIT_TILE && _tile.classid >= lo && _tile.classid <= hi)
  546. {
  547. if(!area || _tile.area == area)
  548. return copyUnit(_tile);
  549. }
  550. } while(_tile.getNext());
  551. }
  552.  
  553. return false;
  554. }
  555.  
  556. function NTM_CheckWPInt(wpHex)
  557. {
  558. debugPrint("ntm checkwpInt" );
  559. for(var i = 0 ; i < 39 ; i++)
  560. {
  561. if(wpHex == NTM_Waypoints[i])
  562. return getWaypoint(i);
  563. }
  564. return false;
  565. }
  566.  
  567. function NTM_FindCorrectPortalInt(blueportal, ownername)
  568. {
  569. debugPrint("ntm findCorrectPortal" );
  570. var _portal = NTC_GetUnit(NTC_UNIT_OBJECT, "Portal");
  571.  
  572. if(blueportal)
  573. {
  574. if(_portal)
  575. {
  576. do
  577. {
  578. if(_portal.type == NTC_UNIT_OBJECT && _portal.mode == 2 && NTC_CheckOwner(_portal, ownername) && getDistance(me, _portal) < 30)
  579. return copyUnit(_portal);
  580. } while(_portal.getNext());
  581. }
  582.  
  583. return -2;
  584. }
  585. else if(_portal)
  586. {
  587. do
  588. {
  589. if(_portal.type == NTC_UNIT_OBJECT && _portal.mode == 2 && !_portal.getParent())
  590. return copyUnit(_portal);
  591. } while(_portal.getNext());
  592. }
  593.  
  594. return -3;
  595. }
  596.  
  597. function NTM_FindPortalAreaInt(dest)
  598. {
  599. debugPrint("ntm FindPortalareaInt" );
  600. var _portal = NTC_GetUnit(NTC_UNIT_OBJECT, "Portal");
  601.  
  602. if(_portal)
  603. {
  604. do
  605. {
  606. if(_portal.type == NTC_UNIT_OBJECT && _portal.mode == 2 && _portal.objtype == dest)
  607. {
  608. if(_portal.getParent())
  609. {
  610. if(NTC_CheckOwner(_portal) || NTC_InMyParty(_portal.getParent()))
  611. return copyUnit(_portal);
  612. }
  613. else
  614. return copyUnit(_portal);
  615. }
  616. } while(_portal.getNext());
  617. }
  618.  
  619. return false;
  620. }
  621.  
  622. function NTM_GetCloserInt(object)
  623. {
  624. debugPrint("ntm getCloser" );
  625. if(getDistance(me, object) > 2)
  626. return NTM_MoveTo(object.x, object.y);
  627.  
  628. return true;
  629. }
  630. function NTM_TravelTO(area)
  631. {
  632. var tries = 0;// moved this out of loop
  633. var stuckAtWP = false;
  634. var StuckAtWPRetries = 5; // times to go to stash in town before you quit();
  635. while (me.area != area){
  636. var notFound = false;
  637.  
  638. var tempAction = currentAction;
  639. var nextlvl =area;
  640. while(!notFound){
  641.  
  642. //print("second loop "+nextlvl);
  643. NTC_Delay(10);
  644. if (tries >50){
  645. //print ("failed to travel to "+area);
  646. return false;
  647. }
  648.  
  649. if(NTC_InTown()){
  650. if (!usedWp){
  651. NTTM_TownMove("waypoint")
  652. NTM_ChangeAreaInt("Waypoint",me.area);
  653. usedWp=true;
  654. }
  655.  
  656. if (NTM_FindPortalAreaInt(nextlvl)){
  657. NTM_ChangeAreaInt("Portal",nextlvl,null,NTM_FindPortalAreaInt(nextlvl));
  658. NTTM_TownMove("portalspot");
  659. //print("break 1");
  660. break;
  661. }
  662. if (NTM_AreaWPArray[nextlvl] && NTM_CheckWPInt(NTM_AreaWPArray[nextlvl])){
  663. if (stuckAtWP == nextlvl){
  664. NTTM_TownMove("stash");
  665. stuckAtWP = false;
  666. StuckAtWPRetries = StuckAtWPRetries-1;
  667. if(StuckAtWPRetries == 0)
  668. quit(); // we got stuck give up :(
  669.  
  670. }
  671. NTTM_TownMove("waypoint")
  672. NTM_ChangeAreaInt("Waypoint",nextlvl);
  673. //print("break 2");
  674. stuckAtWP = nextlvl
  675. usedWp=true;
  676. break;
  677. }
  678. }
  679. if (NTM_GotoLevel(nextlvl,true)){
  680. //print("break 3");
  681. break;
  682.  
  683. }
  684. if (!usedWp && NTM_AreaWPArray[nextlvl]){
  685. NTM_GotoWaypoint(me.area,true,100)
  686. usedWp=true;
  687. }
  688. if (NTM_AreaWPArray[nextlvl] && NTM_CheckWPInt(NTM_AreaWPArray[nextlvl])){
  689. //closer waypoint found but were not in town
  690. if(NTM_GotoWaypoint(me.area,false,100)){
  691. NTM_UsePortal("Waypoint", nextlvl)
  692. break;
  693. }
  694. if (NTTMGR_CheckScrolls(1) > 0){
  695. NTTM_CheckAct()
  696. NTTMGR_TownManager();
  697. NTTM_TownMove("waypoint")
  698. break;
  699. }
  700. if(NTM_GotoWaypoint(me.area)){
  701. NTM_UsePortal("Waypoint",nextlvl)
  702. break;
  703. }
  704.  
  705. }
  706. var curlvl =nextlvl;
  707. nextlvl =NTAR_PreviousAreas[curlvl];
  708. if (me.area == area)
  709. notFound = true;
  710. }
  711. NTP_UpdatePrecast();
  712. }
  713. return true;
  714. }
  715. function NTM_OpenDoor(){ // only opens act 4 town door atm
  716. var myDoor = getUnit(2);
  717. if(myDoor){
  718. do{
  719. if(myDoor.name == "gate" && getDistance(me, myDoor) < 10){
  720. while(myDoor.mode == 0){
  721. clickMap( 0, 0, myDoor );
  722. NTC_Delay(rnd(10,20));
  723. clickMap( 2, 0, myDoor );
  724. NTC_Delay(200);
  725. //myDoor.interact();
  726. }
  727. }
  728. }while(myDoor.getNext());
  729. }
  730. }
  731. function NTM_GotoLevel( exitAreaId, goThru) {
  732. if(typeof(getExits) == 'function'){
  733. var exit = getExits(getArea(me.area));
  734. //print("1.1.2");
  735. }else{
  736. var exit = getArea().exits;
  737. }
  738. if(exitAreaId == 50 && me.area == 40){
  739. NTM_MoveTo(5055,5142);
  740. for(var n in exit) {
  741. if(exit[n].id == exitAreaId)
  742. return NTM_takeTile(exit[n].tileid);
  743. }
  744. }
  745. if(exitAreaId == 51 && me.area == 50){
  746. NTM_MoveTo(10041,5081);
  747. var tile =getUnit(5);
  748. tile.interact();
  749. preWalkDelay;
  750. postWalkDelay;
  751. return true;
  752. }
  753. if(exitAreaId == 110 && me.area == 109){ //bloody hills
  754. NTM_MoveTo(5065,5098);
  755. NTM_MoveTo(5025,5096);
  756. NTM_OpenDoor();
  757. }
  758. if(exitAreaId == 38 && me.area == 4){ //trist
  759. if(!NTM_MoveToObject(NTC_UNIT_OBJECT, 17, 17, 5, 5))
  760. return false;
  761. NTC_Delay(500);
  762. if(goThru){
  763. if(!NTM_UsePortal("Portal", 38)){
  764. print("Portal Not found");
  765. return false;
  766. }
  767. }
  768. return true;
  769. }
  770. if(exitAreaId == 46 && me.area == 74){ //arcane sant >maji cannon
  771. if(!NTM_MoveToObject(NTC_UNIT_OBJECT, 357, 357, 0, 0))
  772. return false;
  773. var _unit = NTC_GetUnit(NTC_UNIT_OBJECT, 357);
  774. _unit.interact();
  775. _unit.interact();
  776. NTC_Delay(250);
  777. me.cancel(1);
  778. NTC_Delay(600);
  779. if(!NTM_UsePortal("Portal", 46))
  780. return false;
  781. return true;
  782. }
  783.  
  784. for(var n in exit) {
  785. var target;
  786. if (exit[n].id)
  787. target = exit[n].id
  788. else
  789. target = exit[n].target
  790.  
  791. if(target == exitAreaId) {
  792. var oldArea = me.area;
  793. NTM_MoveTo(exit[n].x,exit[n].y);
  794. var TargetID=exit[n].tileid;
  795. if(goThru) {
  796. if(exit[n].type == 2) {
  797. return NTM_takeTile(exit[n].tileid);
  798. }
  799. // if(typeof(getExits) == 'function')
  800. // var otherExit = getExits(getArea(exitAreaId));
  801. // else
  802. // var otherExit = getArea(exitAreaId).exits;
  803.  
  804. //print(otherExit.toSource ());
  805. //for(var l = 0; l < otherExit.length; l++) {
  806. // var otherTarget;
  807. // if (otherExit[n].id)
  808. // otherTarget = exit[n].id
  809. // else
  810. // otherTarget = exit[n].target
  811.  
  812. // if(otherTarget == oldArea) {
  813. NTM_EnterArea(exitAreaId);
  814. if(oldArea == me.area){
  815. clickMap(0, 0, me.x+5, me.y+5);
  816. NTC_Delay(300);
  817. postWalkDelay();
  818. }
  819. if(oldArea == me.area){
  820. NTM_MoveTo(exit[n].x,exit[n].y);
  821. clickMap(0, 0, me.x-5, me.y+5);
  822. postWalkDelay();
  823. }
  824. if(oldArea == me.area){
  825. NTM_MoveTo(exit[n].x,exit[n].y);
  826. clickMap(0, 0, me.x-5, me.y-5);
  827. postWalkDelay();
  828. }
  829. if(oldArea == me.area){
  830. NTM_MoveTo(exit[n].x,exit[n].y);
  831. clickMap(0, 0, me.x+5, me.y-5);
  832. postWalkDelay();
  833. }
  834. //retry bigger
  835. if(oldArea == me.area){
  836. clickMap(0, 0, me.x+10, me.y+10);
  837. postWalkDelay();
  838. }
  839. if(oldArea == me.area){
  840. NTM_MoveTo(exit[n].x,exit[n].y);
  841. clickMap(0, 0, me.x-10, me.y+10);
  842. postWalkDelay();
  843. }
  844. if(oldArea == me.area){
  845. NTM_MoveTo(exit[n].x,exit[n].y);
  846. clickMap(0, 0, me.x-10, me.y-10);
  847. postWalkDelay();
  848. }
  849. if(oldArea == me.area){
  850. NTM_MoveTo(exit[n].x,exit[n].y);
  851. clickMap(0, 0, me.x+10, me.y-10);
  852. postWalkDelay();
  853. }
  854. // }
  855. // }
  856. }
  857. return true;
  858. }
  859. }
  860. return false;
  861. }
  862.  
  863. function NTM_takeTile(tileId) {
  864. //Obtain the unit for the tile and store old area
  865. var tileUnit = (arguments.length > 1) ? getUnit(arguments[1], tileId) : getUnit(5, tileId);
  866. var oldArea = me.area;
  867. //Insure we have the unit
  868.  
  869. //Keep trying to go thru the tile until area changes
  870. var _prearea = me.area;
  871. for(var i = 0 ; i < 100 ; i++){
  872. if((i % 25) == 0){
  873. if(!tileUnit)
  874. return false;
  875. //if(NTM_GetCloserInt(tileUnit))
  876. tileUnit.interact ();
  877. }
  878. NTC_Delay(40);
  879. if(me.area != _prearea)
  880. break;
  881. }
  882. preWalkDelay();
  883.  
  884. while(me.area == 0)
  885. NTC_Delay(NTC_DELAY_FRAME);
  886.  
  887. if(me.area == _prearea)
  888. return false;
  889.  
  890. debugPrint("ntm takeStairsDelay" );
  891. postWalkDelay();
  892. NTC_Delay(50);
  893. return true;
  894.  
  895. }
  896. function NTM_GotoWaypoint( pArea ,get,maxDist) {
  897. print("gotowp");
  898. var match = false;
  899. var _wpidarray = [ 119, 145, 156, 157, 237, 238, 288, 323, 324, 398, 402, 429, 494, 496, 511, 539 ];
  900. var _presetobjects = getPresetUnits( pArea, 2, null, null );
  901. if ( _presetobjects.length == 0 ) {
  902. return false;
  903. }
  904. for ( var i = 0; i < _presetobjects.length; i += 1 ) {
  905. for ( var j = 0; j < _wpidarray.length; j += 1 ) {
  906. if ( _presetobjects[i].id == _wpidarray[j] ) {
  907. if(maxDist && getDistance(me.x,me.y,_presetobjects[i].roomx*5 + _presetobjects[i].x,_presetobjects[i].roomy*5+_presetobjects[i].y) <maxDist){
  908. NTM_MoveTo(_presetobjects[i].roomx*5 + _presetobjects[i].x,_presetobjects[i].roomy*5+_presetobjects[i].y);
  909. match = i;
  910. }else{
  911. return false;
  912. }
  913. }
  914. }
  915. }
  916. if(!match)
  917. return false;
  918. if (get && match){
  919. var wp = getUnit(2,_presetobjects[match].id);
  920. if(wp){
  921.  
  922. var l=0;
  923. //print(getUIFlag(0x14));
  924. while(!getUIFlag(0x14) && l++ < 40){
  925. NTC_DoClick(0,0,wp);
  926. delay(100);
  927. }
  928. l=0;
  929. while(getUIFlag(0x14) && l++ < 40) {
  930. wp.cancel(0);
  931. delay(100);
  932. }
  933. }else
  934. return false;
  935. }
  936. return true;
  937. }
  938.  
  939. function NTM_EnterArea(id)
  940. {
  941. var _room;
  942. var _rooms;
  943. var rx,ry,path,reachable, tempCR,cx,cy
  944. var closeDist =100000;
  945. _room = getRoom(id);
  946.  
  947. if(!_room)
  948. return false;
  949.  
  950. _rooms = new Array();
  951.  
  952. do
  953. {
  954. rx = parseInt(_room.x*5 + _room.xsize/2);
  955. ry = parseInt(_room.y*5 + _room.ysize/2)
  956. //path= getPath(getArea(me.area), me.x, me.y, rx, ry,false);
  957.  
  958. reachable =isRoomReachable(_room);
  959. if (reachable){
  960. _rooms.push([reachable[0],reachable[1]])//[parseInt(_room.x*5 + _room.xsize/2), parseInt(_room.y*5 + _room.ysize/2)]);
  961.  
  962. }
  963.  
  964. } while(_room.getNext());
  965.  
  966.  
  967. _rooms.sort(NTA_SortRoomInt);
  968. _room = _rooms.shift();
  969. //print(_rooms.toSource());
  970. NTM_MoveTo(_room[0], _room[1]);
  971.  
  972.  
  973.  
  974. return false;
  975. }
  976. // vector class
  977. function vector()
  978. {
  979. if(arguments.length == 2)
  980. {
  981. this.x = arguments[0];
  982. this.y = arguments[1];
  983. }
  984. else if(arguments.length == 1)
  985. {
  986. this.x = arguments[0].x;
  987. this.y = arguments[0].y;
  988. }
  989. else
  990. {
  991. this.x = 0;
  992. this.y = 0;
  993. }
  994.  
  995. this.rotate = vector_rotate;
  996. this.normalize = vector_normalize;
  997. this.length = vector_length;
  998. this.setlength = vector_setlength;
  999. this.toString = vector_toString;
  1000. this.set = vector_set;
  1001. this.angle = vector_angle;
  1002. }
  1003.  
  1004. function vector_rotate(degree)
  1005. {
  1006. if(!degree)
  1007. return true;
  1008.  
  1009. var l = this.length();
  1010. if(!l)
  1011. return false;
  1012.  
  1013. this.normalize();
  1014.  
  1015. var rad = degree * (Math.PI/180);
  1016.  
  1017. var nx = this.x * Math.cos(rad) - this.y * Math.sin(rad);
  1018. var ny = this.x * Math.sin(rad) + this.y * Math.cos(rad);
  1019.  
  1020. this.x = nx;
  1021. this.y = ny;
  1022.  
  1023. this.normalize();
  1024. if(l != 1)
  1025. this.setlength(l);
  1026.  
  1027. return true;
  1028. }
  1029.  
  1030. function vector_angle(v)
  1031. {
  1032. var rad_degree = 180 / Math.PI;
  1033.  
  1034. return Math.acos((this.x*v.x) + (this.y*v.y)) * rad_degree;
  1035. }
  1036.  
  1037. function vector_length()
  1038. {
  1039. return Math.sqrt((this.x*this.x) + (this.y*this.y));
  1040. }
  1041.  
  1042. function vector_setlength(length)
  1043. {
  1044. this.normalize();
  1045. this.x *= length;
  1046. this.y *= length;
  1047. }
  1048.  
  1049. function vector_normalize()
  1050. {
  1051. var l = this.length();
  1052. if(!l)
  1053. return false;
  1054.  
  1055. this.x /= l;
  1056. this.y /= l;
  1057.  
  1058. return true;
  1059. }
  1060.  
  1061. function vector_toString()
  1062. {
  1063. str = "(";
  1064. str += Math.round(this.x*1000)/1000;
  1065. str += " , ";
  1066. str += Math.round(this.y*1000)/1000;
  1067. str += ") : ";
  1068. str += Math.round(this.length()*1000)/1000;
  1069.  
  1070. return str;
  1071. }
  1072.  
  1073. function vector_set(tx, ty)
  1074. {
  1075. if(arguments.length == 1)
  1076. {
  1077. this.x = tx.x;
  1078. this.y = tx.y;
  1079. }
  1080. else if(arguments.length == 2)
  1081. {
  1082. this.x = tx;
  1083. this.y = ty;
  1084. }
  1085. }
  1086.  
  1087. // coord class
  1088. function coord()
  1089. {
  1090. this.data = null;
  1091.  
  1092. if(arguments.length == 3)
  1093. {
  1094. this.x = arguments[0];
  1095. this.y = arguments[1];
  1096. this.data = arguments[2];
  1097. }
  1098. else if(arguments.length == 2)
  1099. {
  1100. this.x = arguments[0];
  1101. this.y = arguments[1];
  1102. }
  1103. else if(arguments.length == 1)
  1104. {
  1105. this.x = arguments[0].x;
  1106. this.y = arguments[0].y;
  1107. }
  1108. else
  1109. {
  1110. this.x = 0;
  1111. this.y = 0;
  1112. }
  1113.  
  1114. this.dist = coord_dist;
  1115. this.dist2 = coord_dist2;
  1116. this.dir = coord_dir;
  1117. this.move = coord_move;
  1118. this.set = coord_set;
  1119. this.toString = coord_toString;
  1120. }
  1121.  
  1122. function coord_set(tx, ty, d)
  1123. {
  1124. if(arguments.length == 1)
  1125. {
  1126. this.x = tx.x;
  1127. this.y = tx.y;
  1128.  
  1129. if(tx.data)
  1130. this.data = tx.data;
  1131. else
  1132. this.data = null;
  1133. }
  1134. else if(arguments.length == 2)
  1135. {
  1136. this.x = tx;
  1137. this.y = ty;
  1138. this.data = null;
  1139. }
  1140. else if(arguments.length == 3)
  1141. {
  1142. this.x = tx;
  1143. this.y = ty;
  1144. this.data = d;
  1145. }
  1146. }
  1147.  
  1148. function coord_dist(tx, ty)
  1149. {
  1150. if(arguments.length == 1)
  1151. {
  1152. var vx = this.x - tx.x;
  1153. var vy = this.y - tx.y;
  1154.  
  1155. return Math.round(Math.sqrt((vx*vx) + (vy*vy)));
  1156. }
  1157. else if(arguments.length == 2)
  1158. {
  1159. var vx = this.x - tx;
  1160. var vy = this.y - ty;
  1161.  
  1162. return Math.round(Math.sqrt((vx*vx) + (vy*vy)));
  1163. }
  1164. return false;
  1165. }
  1166.  
  1167. function coord_dist2(tx, ty)
  1168. {
  1169. if(arguments.length == 1)
  1170. {
  1171. vx = this.x - tx.x;
  1172. vy = this.y - tx.y;
  1173.  
  1174. return Math.floor((vx*vx) + (vy*vy));
  1175. }
  1176. else if(arguments.length == 2)
  1177. {
  1178. vx = this.x - tx;
  1179. vy = this.y - ty;
  1180.  
  1181. return Math.floor((vx*vx) + (vy*vy));
  1182. }
  1183. return false;
  1184. }
  1185.  
  1186. function coord_dir(tx, ty)
  1187. {
  1188. if(arguments.length == 1)
  1189. {
  1190. var v = new vector(tx.x-this.x, tx.y-this.y);
  1191. v.normalize();
  1192.  
  1193. return v;
  1194. }
  1195. else if(arguments.length == 2)
  1196. {
  1197. v = new vector(tx-this.x, ty-this.y);
  1198. v.normalize();
  1199.  
  1200. return v;
  1201. }
  1202. return false;
  1203. }
  1204.  
  1205. function coord_move(vec, d)
  1206. {
  1207. if(d)
  1208. {
  1209. this.x += Math.round(vec.x*d);
  1210. this.y += Math.round(vec.y*d);
  1211.  
  1212. return true;
  1213. }
  1214. else if(vec.length())
  1215. {
  1216. this.x += Math.round(vec.x);
  1217. this.y += Math.round(vec.y);
  1218.  
  1219. return true;
  1220. }
  1221.  
  1222. return false;
  1223. }
  1224.  
  1225. function coord_toString()
  1226. {
  1227. return "( " + this.x + " , " + this.y + " ) " + this.data;
  1228. }
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!