API tools faq
paste
Advertisement
Guest User

Maptest Bot

a guest
Jul 15th, 2019
112
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 28.64 KB | None | 0 0
raw download clone embed print report
  1. // ==UserScript==
  2. // @name TagPro defense bot sniper
  3. // @description f to attack g to snipe. make wise use dont get caught.
  4. // @version
  5. //@grant tagpro.ready
  6. // @include http://*.newcompte.fr:*
  7. // @match *://*.koalabeast.com/game
  8. // @license ****
  9. // @author *******
  10. // @namespace ***********************************
  11. // ==/UserScript==
  12. /*
  13. Tested against Chromium build with Object.observe and acts EXACTLY the same,
  14. though Chromium build is MUCH faster
  15.  
  16. Trying to stay as close to the spec as possible,
  17. this is a work in progress, feel free to comment/update
  18.  
  19. Specification:
  20. http://wiki.ecmascript.org/doku.php?id=harmony:observe
  21.  
  22. Built using parts of:
  23. https://github.com/tvcutsem/harmony-reflect/blob/master/examples/observer.js
  24.  
  25. Limits so far;
  26. Built using polling... Will update again with polling/getter&setters to make things better at some point
  27.  
  28. TODO:
  29. Add support for Object.prototype.watch -> https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/watch
  30. */
  31.  
  32. if(!Object.observe){
  33. (function(extend, global){
  34. "use strict";
  35. var isCallable = (function(toString){
  36. var s = toString.call(toString),
  37. u = typeof u;
  38. return typeof global.alert === "object" ?
  39. function isCallable(f){
  40. return s === toString.call(f) || (!!f && typeof f.toString == u && typeof f.valueOf == u && /^\s*\bfunction\b/.test("" + f));
  41. }:
  42. function isCallable(f){
  43. return s === toString.call(f);
  44. }
  45. ;
  46. })(extend.prototype.toString);
  47. // isNode & isElement from http://stackoverflow.com/questions/384286/javascript-isdom-how-do-you-check-if-a-javascript-object-is-a-dom-object
  48. //Returns true if it is a DOM node
  49. var isNode = function isNode(o){
  50. return (
  51. typeof Node === "object" ? o instanceof Node :
  52. o && typeof o === "object" && typeof o.nodeType === "number" && typeof o.nodeName==="string"
  53. );
  54. }
  55. //Returns true if it is a DOM element
  56. var isElement = function isElement(o){
  57. return (
  58. typeof HTMLElement === "object" ? o instanceof HTMLElement : //DOM2
  59. o && typeof o === "object" && o !== null && o.nodeType === 1 && typeof o.nodeName==="string"
  60. );
  61. }
  62. var _isImmediateSupported = (function(){
  63. return !!global.setImmediate;
  64. })();
  65. var _doCheckCallback = (function(){
  66. if(_isImmediateSupported){
  67. return function _doCheckCallback(f){
  68. return setImmediate(f);
  69. };
  70. }else{
  71. return function _doCheckCallback(f){
  72. return setTimeout(f, 10);
  73. };
  74. }
  75. })();
  76. var _clearCheckCallback = (function(){
  77. if(_isImmediateSupported){
  78. return function _clearCheckCallback(id){
  79. clearImmediate(id);
  80. };
  81. }else{
  82. return function _clearCheckCallback(id){
  83. clearTimeout(id);
  84. };
  85. }
  86. })();
  87. var isNumeric=function isNumeric(n){
  88. return !isNaN(parseFloat(n)) && isFinite(n);
  89. };
  90. var sameValue = function sameValue(x, y){
  91. if(x===y){
  92. return x !== 0 || 1 / x === 1 / y;
  93. }
  94. return x !== x && y !== y;
  95. };
  96. var isAccessorDescriptor = function isAccessorDescriptor(desc){
  97. if (typeof(desc) === 'undefined'){
  98. return false;
  99. }
  100. return ('get' in desc || 'set' in desc);
  101. };
  102. var isDataDescriptor = function isDataDescriptor(desc){
  103. if (typeof(desc) === 'undefined'){
  104. return false;
  105. }
  106. return ('value' in desc || 'writable' in desc);
  107. };
  108.  
  109. var validateArguments = function validateArguments(O, callback, accept){
  110. if(typeof(O)!=='object'){
  111. // Throw Error
  112. throw new TypeError("Object.observeObject called on non-object");
  113. }
  114. if(isCallable(callback)===false){
  115. // Throw Error
  116. throw new TypeError("Object.observeObject: Expecting function");
  117. }
  118. if(Object.isFrozen(callback)===true){
  119. // Throw Error
  120. throw new TypeError("Object.observeObject: Expecting unfrozen function");
  121. }
  122. if (accept !== undefined) {
  123. if (!Array.isArray(accept)) {
  124. throw new TypeError("Object.observeObject: Expecting acceptList in the form of an array");
  125. }
  126. }
  127. };
  128.  
  129. var Observer = (function Observer(){
  130. var wraped = [];
  131. var Observer = function Observer(O, callback, accept){
  132. validateArguments(O, callback, accept);
  133. if (!accept) {
  134. accept = ["add", "update", "delete", "reconfigure", "setPrototype", "preventExtensions"];
  135. }
  136. Object.getNotifier(O).addListener(callback, accept);
  137. if(wraped.indexOf(O)===-1){
  138. wraped.push(O);
  139. }else{
  140. Object.getNotifier(O)._checkPropertyListing();
  141. }
  142. };
  143.  
  144. Observer.prototype.deliverChangeRecords = function Observer_deliverChangeRecords(O){
  145. Object.getNotifier(O).deliverChangeRecords();
  146. };
  147.  
  148. wraped.lastScanned = 0;
  149. var f = (function f(wrapped){
  150. return function _f(){
  151. var i = 0, l = wrapped.length, startTime = new Date(), takingTooLong=false;
  152. for(i=wrapped.lastScanned; (i<l)&&(!takingTooLong); i++){
  153. if(_indexes.indexOf(wrapped[i]) > -1){
  154. Object.getNotifier(wrapped[i])._checkPropertyListing();
  155. takingTooLong=((new Date())-startTime)>100; // make sure we don't take more than 100 milliseconds to scan all objects
  156. }else{
  157. wrapped.splice(i, 1);
  158. i--;
  159. l--;
  160. }
  161. }
  162. wrapped.lastScanned=i<l?i:0; // reset wrapped so we can make sure that we pick things back up
  163. _doCheckCallback(_f);
  164. };
  165. })(wraped);
  166. _doCheckCallback(f);
  167. return Observer;
  168. })();
  169.  
  170. var Notifier = function Notifier(watching){
  171. var _listeners = [], _acceptLists = [], _updates = [], _updater = false, properties = [], values = [];
  172. var self = this;
  173. Object.defineProperty(self, '_watching', {
  174. enumerable: true,
  175. get: (function(watched){
  176. return function(){
  177. return watched;
  178. };
  179. })(watching)
  180. });
  181. var wrapProperty = function wrapProperty(object, prop){
  182. var propType = typeof(object[prop]), descriptor = Object.getOwnPropertyDescriptor(object, prop);
  183. if((prop==='getNotifier')||isAccessorDescriptor(descriptor)||(!descriptor.enumerable)){
  184. return false;
  185. }
  186. if((object instanceof Array)&&isNumeric(prop)){
  187. var idx = properties.length;
  188. properties[idx] = prop;
  189. values[idx] = object[prop];
  190. return true;
  191. }
  192. (function(idx, prop){
  193. properties[idx] = prop;
  194. values[idx] = object[prop];
  195. function getter(){
  196. return values[getter.info.idx];
  197. }
  198. function setter(value){
  199. if(!sameValue(values[setter.info.idx], value)){
  200. Object.getNotifier(object).queueUpdate(object, prop, 'update', values[setter.info.idx]);
  201. values[setter.info.idx] = value;
  202. }
  203. }
  204. getter.info = setter.info = {
  205. idx: idx
  206. };
  207. Object.defineProperty(object, prop, {
  208. get: getter,
  209. set: setter
  210. });
  211. })(properties.length, prop);
  212. return true;
  213. };
  214. self._checkPropertyListing = function _checkPropertyListing(dontQueueUpdates){
  215. var object = self._watching, keys = Object.keys(object), i=0, l=keys.length;
  216. var newKeys = [], oldKeys = properties.slice(0), updates = [];
  217. var prop, queueUpdates = !dontQueueUpdates, propType, value, idx, aLength;
  218.  
  219. if(object instanceof Array){
  220. aLength = self._oldLength;//object.length;
  221. //aLength = object.length;
  222. }
  223.  
  224. for(i=0; i<l; i++){
  225. prop = keys[i];
  226. value = object[prop];
  227. propType = typeof(value);
  228. if((idx = properties.indexOf(prop))===-1){
  229. if(wrapProperty(object, prop)&&queueUpdates){
  230. self.queueUpdate(object, prop, 'add', null, object[prop]);
  231. }
  232. }else{
  233. if(!(object instanceof Array)||(isNumeric(prop))){
  234. if(values[idx] !== value){
  235. if(queueUpdates){
  236. self.queueUpdate(object, prop, 'update', values[idx], value);
  237. }
  238. values[idx] = value;
  239. }
  240. }
  241. oldKeys.splice(oldKeys.indexOf(prop), 1);
  242. }
  243. }
  244.  
  245. if(object instanceof Array && object.length !== aLength){
  246. if(queueUpdates){
  247. self.queueUpdate(object, 'length', 'update', aLength, object);
  248. }
  249. self._oldLength = object.length;
  250. }
  251.  
  252. if(queueUpdates){
  253. l = oldKeys.length;
  254. for(i=0; i<l; i++){
  255. idx = properties.indexOf(oldKeys[i]);
  256. self.queueUpdate(object, oldKeys[i], 'delete', values[idx]);
  257. properties.splice(idx,1);
  258. values.splice(idx,1);
  259. for(var i=idx;i<properties.length;i++){
  260. if(!(properties[i] in object))
  261. continue;
  262. var getter = Object.getOwnPropertyDescriptor(object,properties[i]).get;
  263. if(!getter)
  264. continue;
  265. var info = getter.info;
  266. info.idx = i;
  267. }
  268. };
  269. }
  270. };
  271. self.addListener = function Notifier_addListener(callback, accept){
  272. var idx = _listeners.indexOf(callback);
  273. if(idx===-1){
  274. _listeners.push(callback);
  275. _acceptLists.push(accept);
  276. }
  277. else {
  278. _acceptLists[idx] = accept;
  279. }
  280. };
  281. self.removeListener = function Notifier_removeListener(callback){
  282. var idx = _listeners.indexOf(callback);
  283. if(idx>-1){
  284. _listeners.splice(idx, 1);
  285. _acceptLists.splice(idx, 1);
  286. }
  287. };
  288. self.listeners = function Notifier_listeners(){
  289. return _listeners;
  290. };
  291. self.queueUpdate = function Notifier_queueUpdate(what, prop, type, was){
  292. this.queueUpdates([{
  293. type: type,
  294. object: what,
  295. name: prop,
  296. oldValue: was
  297. }]);
  298. };
  299. self.queueUpdates = function Notifier_queueUpdates(updates){
  300. var self = this, i = 0, l = updates.length||0, update;
  301. for(i=0; i<l; i++){
  302. update = updates[i];
  303. _updates.push(update);
  304. }
  305. if(_updater){
  306. _clearCheckCallback(_updater);
  307. }
  308. _updater = _doCheckCallback(function(){
  309. _updater = false;
  310. self.deliverChangeRecords();
  311. });
  312. };
  313. self.deliverChangeRecords = function Notifier_deliverChangeRecords(){
  314. var i = 0, l = _listeners.length,
  315. //keepRunning = true, removed as it seems the actual implementation doesn't do this
  316. // In response to BUG #5
  317. retval;
  318. for(i=0; i<l; i++){
  319. if(_listeners[i]){
  320. var currentUpdates;
  321. if (_acceptLists[i]) {
  322. currentUpdates = [];
  323. for (var j = 0, updatesLength = _updates.length; j < updatesLength; j++) {
  324. if (_acceptLists[i].indexOf(_updates[j].type) !== -1) {
  325. currentUpdates.push(_updates[j]);
  326. }
  327. }
  328. }
  329. else {
  330. currentUpdates = _updates;
  331. }
  332. if (currentUpdates.length) {
  333. if(_listeners[i]===console.log){
  334. console.log(currentUpdates);
  335. }else{
  336. _listeners[i](currentUpdates);
  337. }
  338. }
  339. }
  340. }
  341. _updates=[];
  342. };
  343. self.notify = function Notifier_notify(changeRecord) {
  344. if (typeof changeRecord !== "object" || typeof changeRecord.type !== "string") {
  345. throw new TypeError("Invalid changeRecord with non-string 'type' property");
  346. }
  347. changeRecord.object = watching;
  348. self.queueUpdates([changeRecord]);
  349. };
  350. self._checkPropertyListing(true);
  351. };
  352.  
  353. var _notifiers=[], _indexes=[];
  354. extend.getNotifier = function Object_getNotifier(O){
  355. var idx = _indexes.indexOf(O), notifier = idx>-1?_notifiers[idx]:false;
  356. if(!notifier){
  357. idx = _indexes.length;
  358. _indexes[idx] = O;
  359. notifier = _notifiers[idx] = new Notifier(O);
  360. }
  361. return notifier;
  362. };
  363. extend.observe = function Object_observe(O, callback, accept){
  364. // For Bug 4, can't observe DOM elements tested against canry implementation and matches
  365. if(!isElement(O)){
  366. return new Observer(O, callback, accept);
  367. }
  368. };
  369. extend.unobserve = function Object_unobserve(O, callback){
  370. validateArguments(O, callback);
  371. var idx = _indexes.indexOf(O),
  372. notifier = idx>-1?_notifiers[idx]:false;
  373. if (!notifier){
  374. return;
  375. }
  376. notifier.removeListener(callback);
  377. if (notifier.listeners().length === 0){
  378. _indexes.splice(idx, 1);
  379. _notifiers.splice(idx, 1);
  380. }
  381. };
  382. })(Object, this);
  383. }
  384.  
  385. tagpro.ready(function tagBot() {
  386. if (!tagpro.playerId) return setTimeout(tagBot, 250);
  387.  
  388. var snipe = false,
  389. attack = false,
  390. sentDir = {r: false, l: false, d: false, u: false},
  391. keyDir = {r: false, l: false, d: false, u: false},
  392. keyCount = 1,
  393. tse = tagpro.socket.emit;
  394.  
  395. tagpro.socket.emit = function (t, n) {
  396. if (t === 'keydown') {
  397. if (n.k === 'right') sentDir.r = true;
  398. if (n.k === 'left') sentDir.l = true;
  399. if (n.k === 'down') sentDir.d = true;
  400. if (n.k === 'up') sentDir.u = true;
  401. }
  402. if (t === 'keyup') {
  403. if (n.k === 'right') sentDir.r = false;
  404. if (n.k === 'left') sentDir.l = false;
  405. if (n.k === 'down') sentDir.d = false;
  406. if (n.k === 'up') sentDir.u = false;
  407. }
  408. if (n.t) n.t = keyCount++;
  409. tse(t, n);
  410. };
  411.  
  412. document.onkeydown = function (d) {
  413. d = d || window.event;
  414. switch(d.keyCode) {
  415. case 18:
  416. if (!attack) {
  417. attack = true;
  418. }
  419. break;
  420. case 88:
  421. if (!snipe) {
  422. snipe = true;
  423. }
  424. break;
  425. case tagpro.keys.right[0]: case tagpro.keys.right[1]: case tagpro.keys.right[2]:
  426. if (!keyDir.r) {
  427. if (!tagpro.disableControls && !sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});
  428. keyDir.r = true;
  429. }
  430. break;
  431. case tagpro.keys.left[0]: case tagpro.keys.left[1]: case tagpro.keys.left[2]:
  432. if (!keyDir.l) {
  433. if (!tagpro.disableControls && !sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});
  434. keyDir.l = true;
  435. }
  436. break;
  437. case tagpro.keys.down[0]: case tagpro.keys.down[1]: case tagpro.keys.down[2]:
  438. if (!keyDir.d) {
  439. if (!tagpro.disableControls && !sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});
  440. keyDir.d = true;
  441. }
  442. break;
  443. case tagpro.keys.up[0]: case tagpro.keys.up[1]: case tagpro.keys.up[2]:
  444. if (!keyDir.u) {
  445. if (!tagpro.disableControls && !sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});
  446. keyDir.u = true;
  447. }
  448. break;
  449. }
  450. };
  451.  
  452. document.onkeyup = function (u) {
  453. u = u || window.event;
  454. switch(u.keyCode) {
  455. case 18:
  456. attack = false;
  457. if (!keyDir.r && sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});
  458. if (!keyDir.l && sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});
  459. if (!keyDir.d && sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});
  460. if (!keyDir.u && sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});
  461. if (keyDir.r && !sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});
  462. if (keyDir.l && !sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});
  463. if (keyDir.d && !sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});
  464. if (keyDir.u && !sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});
  465. break;
  466. case 88:
  467. snipe = false;
  468. attack = false;
  469. if (!keyDir.r && sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});
  470. if (!keyDir.l && sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});
  471. if (!keyDir.d && sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});
  472. if (!keyDir.u && sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});
  473. if (keyDir.r && !sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});
  474. if (keyDir.l && !sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});
  475. if (keyDir.d && !sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});
  476. if (keyDir.u && !sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});
  477. break;
  478. case tagpro.keys.right[0]: case tagpro.keys.right[1]: case tagpro.keys.right[2]:
  479. if (!tagpro.disableControls && sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});
  480. keyDir.r = false;
  481. break;
  482. case tagpro.keys.left[0]: case tagpro.keys.left[1]: case tagpro.keys.left[2]:
  483. if (!tagpro.disableControls && sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});
  484. keyDir.l = false;
  485. break;
  486. case tagpro.keys.down[0]: case tagpro.keys.down[1]: case tagpro.keys.down[2]:
  487. if (!tagpro.disableControls && sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});
  488. keyDir.d = false;
  489. break;
  490. case tagpro.keys.up[0]: case tagpro.keys.up[1]: case tagpro.keys.up[2]:
  491. if (!tagpro.disableControls && sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});
  492. keyDir.u = false;
  493. break;
  494. }
  495. };
  496.  
  497. Object.observe(tagpro.players, function(changes) {
  498. changes.forEach(function(change) {
  499. if (change.type === 'add') watchPlayers();
  500. });
  501. });
  502.  
  503. function watchPlayers() {
  504. for (var id in tagpro.players) {
  505. if (!tagpro.players.hasOwnProperty(id)) break;
  506. var player = tagpro.players[id];
  507. if (player.watched === undefined) {
  508. player.sx = 0; player.sy = 0;
  509. player.pr = 0; player.pl = 0;
  510. player.pd = 0; player.pu = 0;
  511. Object.observe(player, function(changes) {
  512. changes.forEach(function(change) {
  513. if (change.name === 'x') getSpeed(changes[0].object, change.oldValue);
  514. if (change.name === 'y') getSpeed(changes[0].object, undefined, change.oldValue);
  515. if (changes[0].object.id !== tagpro.playerId) {
  516. switch (change.name) {
  517. case 'right': case 'left': case 'down': case 'up':
  518. getKeys(changes[0].object);
  519. break;
  520. }
  521. }
  522. });
  523. });
  524. player.watched = true;
  525. }
  526. }
  527. }
  528. watchPlayers();
  529.  
  530. function getSpeed(player, x, y) {
  531. if (x) {
  532. player.sx = player.lx > 0 ? Math.abs(player.x-x)*34 : -Math.abs(player.x-x)*34;
  533. if (!player.lx) player.sx = 0;
  534. }
  535. if (y) {
  536. player.sy = player.ly > 0 ? Math.abs(player.y-y)*34 : -Math.abs(player.y-y)*34;
  537. if (!player.ly) player.sy = 0;
  538. }
  539. }
  540.  
  541. function getKeys(player) {
  542. if (player.right && !player.left) player.pr = 1; else player.pr = 0;
  543. if (player.left && !player.right) player.pl = -1; else player.pl = 0;
  544. if (player.down && !player.up) player.pd = 1; else player.pd = 0;
  545. if (player.up && !player.down) player.pu = -1; else player.pu = 0;
  546. }
  547.  
  548. function attackEnemy() {
  549. var distance,
  550. target,
  551. closest = 9999,
  552. seek = {x: 0, y: 0},
  553. self = tagpro.players[tagpro.playerId];
  554. for (var id in tagpro.players) {
  555. if (tagpro.players.hasOwnProperty(id)) {
  556. var player = tagpro.players[id];
  557. if (player.team !== self.team && player.draw && !player.dead) {
  558. distance = Math.sqrt(Math.pow(player.x+player.lx*30-self.x+self.lx*30, 2)+Math.pow(player.y+player.ly*30-self.y+self.ly*30, 2));
  559. if (attack) {
  560. if (player.flag && distance < 400) {
  561. target = player; break;
  562. } else {
  563. if (distance < closest) {closest = distance; target = player;}
  564. }
  565. }
  566. if (snipe) {
  567. if (player.flag) {
  568. target = player; break;
  569. } else {
  570. if (distance < closest) {closest = distance; target = player;}
  571. }
  572. }
  573. }
  574. }
  575. }
  576. if (target) {
  577. var difX = Math.abs((self.x+self.sx)-(target.x+target.sx)),
  578. difY = Math.abs((self.y+self.sy)-(target.y+target.sy)),
  579. speedDifX = self.sx-target.sx,
  580. speedDifY = self.sy-target.sy,
  581. pressR = target.pr ? Math.min((target.pr*20-speedDifX*0.07)*difY/40, 160) : 0,
  582. pressL = target.pl ? Math.max((target.pl*20-speedDifX*0.07)*difY/40, -160) : 0,
  583. pressD = target.pd ? Math.min((target.pd*20-speedDifY*0.07)*difX/40, 160) : 0,
  584. pressU = target.pu ? Math.max((target.pu*20-speedDifY*0.07)*difX/40, -160) : 0,
  585. pR = target.pr ? target.pr*(1+difY/25) : 0,
  586. pL = target.pl ? target.pl*(1+difY/25) : 0,
  587. pD = target.pd ? target.pd*(1+difX/25) : 0,
  588. pU = target.pu ? target.pu*(1+difX/25) : 0;
  589. if (attack) {
  590. seek.x = (target.x+target.sx*((difX/40+5)/6)+pressR+pressL-speedDifX*difY/400)-(self.x+self.sx*((difX/40+5)/6));
  591. seek.y = (target.y+target.sy*((difY/40+5)/6)+pressD+pressU-speedDifY*difX/400)-(self.y+self.sy*((difY/40+5)/6));
  592. if (seek.x > 6 && !sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});
  593. else {if (seek.x < 3 && sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});}
  594. if (seek.x < -6 && !sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});
  595. else {if (seek.x > -3 && sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});}
  596. if (seek.y > 6 && !sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});
  597. else {if (seek.y < 3 && sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});}
  598. if (seek.y < -6 && !sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});
  599. else {if (seek.y > -3 && sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});}
  600. }
  601. if (snipe && !attack) {
  602. if (Math.abs(self.sx) < 142 || Math.abs(self.sy) < 142) {
  603. seek.x = (target.x+target.sx*(0.5+difY/380)+pR+pL)-(self.x+self.sx*(1+difY/40));
  604. seek.y = (target.y+target.sy*(0.5+difX/380)+pD+pU)-(self.y+self.sy*(1+difX/40));
  605. var timerLength = 140,
  606. timer = Date.now() % timerLength,
  607. timeX = Math.abs(seek.x/seek.y)*timerLength,
  608. timeY = Math.abs(seek.y/seek.x)*timerLength;
  609. if (seek.x > Math.abs(seek.y)) {
  610. if (sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});
  611. if (!sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});
  612. if (timer < timeY && seek.y > 0) {if (!sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});}
  613. else {if (sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});}
  614. if (timer < timeY && seek.y < 0) {if (!sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});}
  615. else {if (sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});}
  616. }
  617. if (seek.x < -Math.abs(seek.y)) {
  618. if (sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});
  619. if (!sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});
  620. if (timer < timeY && seek.y > 0) {if (!sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});}
  621. else {if (sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});}
  622. if (timer < timeY && seek.y < 0) {if (!sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});}
  623. else {if (sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});}
  624. }
  625. if (seek.y > Math.abs(seek.x)) {
  626. if (sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});
  627. if (!sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});
  628. if (timer < timeX && seek.x > 0) {if (!sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});}
  629. else {if (sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});}
  630. if (timer < timeX && seek.x < 0) {if (!sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});}
  631. else {if (sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});}
  632. }
  633. if (seek.y < -Math.abs(seek.x)) {
  634. if (sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});
  635. if (!sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});
  636. if (timer < timeX && seek.x > 0) {if (!sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});}
  637. else {if (sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});}
  638. if (timer < timeX && seek.x < 0) {if (!sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});}
  639. else {if (sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});}
  640. }
  641. } else {
  642. if (!keyDir.r && sentDir.r) tagpro.socket.emit('keyup', {k: 'right', t: keyCount});
  643. if (!keyDir.l && sentDir.l) tagpro.socket.emit('keyup', {k: 'left', t: keyCount});
  644. if (!keyDir.d && sentDir.d) tagpro.socket.emit('keyup', {k: 'down', t: keyCount});
  645. if (!keyDir.u && sentDir.u) tagpro.socket.emit('keyup', {k: 'up', t: keyCount});
  646. if (keyDir.r && !sentDir.r) tagpro.socket.emit('keydown', {k: 'right', t: keyCount});
  647. if (keyDir.l && !sentDir.l) tagpro.socket.emit('keydown', {k: 'left', t: keyCount});
  648. if (keyDir.d && !sentDir.d) tagpro.socket.emit('keydown', {k: 'down', t: keyCount});
  649. if (keyDir.u && !sentDir.u) tagpro.socket.emit('keydown', {k: 'up', t: keyCount});
  650. attack = true;
  651. }
  652. }
  653. }
  654. setTimeout(attackEnemy, 11);
  655. }
  656. attackEnemy();
  657. });
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!