☰

VOXploit

Aimbot, triggerbot, chams, no-recoil for voxiom.io

  1. // ==UserScript==
  2. // @name        VOXploit
  3. // @namespace   http://tampermonkey.net/
  4. // @match       https://voxiom.io/*
  5. // @run-at      document-start
  6. // @grant       none
  7. // @version     1.0.1
  8. // @author      Cloud1
  9. // @description Aimbot, triggerbot, chams, no-recoil for voxiom.io
  10. // @license     GPL
  11. // @require     https://cdn.jsdelivr.net/npm/lil-gui@0.19.2/dist/lil-gui.umd.min.js
  12. // @require     https://unpkg.com/three@0.150.0/build/three.min.js
  13. // @icon        https://www.google.com/s2/favicons?sz=64&domain=voxiom.io
  14. // ==/UserScript==
  15.  
  16. const THREE = window.THREE;
  17. delete window.THREE;
  18.  
  19. // avoid detection
  20. const matchDetection = /^function\(\){\w+\['\w+'\]\(\);}$/;
  21. const setIntervalHandler = {
  22.   apply: function(target, thisArg, argumentsList) {
  23.     const callback = argumentsList[0];
  24.     const delay = argumentsList[1];
  25.     if (delay === 1000 && callback && callback.toString().match(matchDetection)) {
  26.       console.log('Blocked detection');
  27.       return null;
  28.     }
  29.     return Reflect.apply(...arguments);
  30.   }
  31. };
  32. window.setInterval = new Proxy(window.setInterval, setIntervalHandler);
  33.  
  34. // add #lil-gui container
  35. const lilGuiContainer = document.createElement('div');
  36. lilGuiContainer.id = 'lil-gui';
  37. document.body.appendChild(lilGuiContainer);
  38.  
  39. const style = document.createElement('style');
  40. const guiStyle = document.createElement('style');
  41. const GUI = lil.GUI;
  42. const gui = new GUI({ container: lilGuiContainer, title: 'Controls' });
  43.  
  44. let espConfig = {
  45.   heightLine: 1.16,
  46.   sneakHeight: 0.4,
  47.   ennemyDistance: 50,
  48.   maxAngleInRadians: 0.1,
  49.   noRecoil: true,
  50.   showBox: 0,
  51.   showOutline: 0,
  52.   showPlayer: 2,
  53.   showLine: 1,
  54.   wireframe: false,
  55.   allEnnemies: false,
  56.   isSniper: false,
  57.   aimbot: 2,
  58.   triggerBot: 2,
  59.   aimbotIgnoreWall: false,
  60.   mapZoom: 30,
  61.   mapOffsetZ: 0,
  62.   autoClaimAds: false,
  63.   antiAFK: false,
  64.   rainbow: false,
  65.   showAimRadius: false,
  66.   lockAimbotTriggerBot: false,
  67.   aimbotKey: 'b',
  68.   triggerBotKey: 't',
  69.   toggleUIKey: '.',
  70. };
  71.  
  72. const aimbotFolder = gui.addFolder('Aimbot');
  73. aimbotFolder.add(espConfig, 'aimbot').name(`aimbot (${espConfig.aimbotKey})`).options({Off: 0, LeftClick: 1, RightClick: 2, Always: 3}).listen();
  74. aimbotFolder.add(espConfig, 'triggerBot').name(`triggerBot (${espConfig.triggerBotKey})`).options({Off: 0, LeftClick: 1, RightClick: 2, Always: 3}).listen();
  75. aimbotFolder.add(espConfig, 'noRecoil');
  76. aimbotFolder.add(espConfig, 'allEnnemies');
  77. aimbotFolder.add(espConfig, 'isSniper');
  78. const advancedAimbotFolder = aimbotFolder.addFolder('Advanced');
  79. advancedAimbotFolder.close();
  80. advancedAimbotFolder.add(espConfig, 'aimbotIgnoreWall');
  81. advancedAimbotFolder.add(espConfig, 'showAimRadius');
  82. advancedAimbotFolder.add(espConfig, 'maxAngleInRadians', 0.01, 0.5, 0.01);
  83. advancedAimbotFolder.add(espConfig, 'heightLine', .5, 1.25, 0.01);
  84. advancedAimbotFolder.add(espConfig, 'sneakHeight', 0, 1, 0.01);
  85.  
  86. const chamsFolder = gui.addFolder('Chams');
  87. chamsFolder.close();
  88. chamsFolder.add(espConfig, 'showPlayer').options({Off: 0, Ennemies: 1, All: 2});
  89. chamsFolder.add(espConfig, 'showLine').options({Off: 0, Ennemies: 1, All: 2});
  90. chamsFolder.add(espConfig, 'showOutline').options({Off: 0, Ennemies: 1, All: 2});
  91. chamsFolder.add(espConfig, 'showBox').options({Off: 0, Ennemies: 1, All: 2});
  92. chamsFolder.add(espConfig, 'ennemyDistance', 10, 100, 1);
  93. chamsFolder.add(espConfig, 'wireframe');
  94. chamsFolder.add(espConfig, 'rainbow');
  95. chamsFolder.add(espConfig, 'mapZoom', 20, 100, 1);
  96. chamsFolder.add(espConfig, 'mapOffsetZ', -50, 50, 1);
  97.  
  98. const toolsFolder = gui.addFolder('Tools');
  99. toolsFolder.close();
  100. toolsFolder.add(espConfig, 'autoClaimAds');
  101. toolsFolder.add(espConfig, 'antiAFK');
  102. toolsFolder.add(espConfig, 'lockAimbotTriggerBot');
  103.  
  104. // load/save config
  105. const configFolder = gui.addFolder('Config');
  106. configFolder.add(espConfig, 'toggleUIKey').name('Toggle UI key');
  107. configFolder.add(espConfig, 'aimbotKey').name('Aimbot key');
  108. configFolder.add(espConfig, 'triggerBotKey').name('Triggerbot key');
  109. configFolder.close();
  110. const defaultConfig = gui.save();
  111. let config = { configName: 'espConfig' };
  112. configFolder.add(config, 'configName').name('Config name');
  113. configFolder.add({ export: () => {
  114.   const currentConfig = JSON.stringify(gui.save(), null, 2);
  115.   const element = document.createElement('a');
  116.   element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(currentConfig));
  117.   element.setAttribute('download', config.configName + '.json');
  118.   element.style.display = 'none';
  119.   document.body.appendChild(element);
  120.   element.click();
  121.   document.body.removeChild(element);
  122. }}, 'export').name('Export config');
  123. configFolder.add({ import: () => {
  124.   const input = document.createElement('input');
  125.   input.type = 'file';
  126.   input.accept = '.json';
  127.   input.onchange = (e) => {
  128.     const file = e.target.files[0];
  129.     const reader = new FileReader();
  130.     reader.onload = (e) => {
  131.       gui.load(JSON.parse(e.target.result));
  132.     };
  133.     reader.readAsText(file);
  134.   };
  135.   input.click();
  136. }}, 'import').name('Import config');
  137. configFolder.add({ reset: () => {
  138.   gui.load(defaultConfig);
  139.   localStorage.removeItem('espConfig');
  140. }}, 'reset').name('Reset config');
  141.  
  142. // auto load/save config
  143. const savedConfig = localStorage.getItem('espConfig');
  144. if (savedConfig) {
  145.   console.log('Loaded config', savedConfig);
  146.   gui.load(JSON.parse(savedConfig));
  147. }
  148. gui.onChange(() => {
  149.   localStorage.setItem('espConfig', JSON.stringify(gui.save()));
  150. });
  151.  
  152. // listen for key press
  153. document.addEventListener('keydown', (e) => {
  154.   if (!espConfig.lockAimbotTriggerBot && e.key === espConfig.aimbotKey) {
  155.     espConfig.aimbot = (espConfig.aimbot + 1) % 4;
  156.   }
  157.   if (!espConfig.lockAimbotTriggerBot && e.key === espConfig.triggerBotKey) {
  158.     espConfig.triggerBot = (espConfig.triggerBot + 1) % 4;
  159.   }
  160.   if (e.key === espConfig.toggleUIKey) {
  161.     lilGuiContainer.style.display = lilGuiContainer.style.display === 'none' ? 'block' : 'none';
  162.   }
  163.   if (e.key === 'e') {
  164.     if (espConfig.autoClaimAds) {
  165.       setTimeout(() => {
  166.         claimAds();
  167.       }, 100);
  168.     }
  169.   }
  170. });
  171.  
  172. // no-recoil
  173. let foundRecoil = false;
  174. const arrayPushHandler = {
  175.   apply: function(target, thisArg, argumentsList) {
  176.     if (!foundRecoil && argumentsList.length === 1) {
  177.       const item = argumentsList[0];
  178.       if (item && typeof item === 'object') {
  179.         const keys = Object.keys(item);
  180.         if (keys.length === 44) {
  181.           for (const key in item) {
  182.             if (item[key] === 0.3) {
  183.               console.log('Recoil key found', key);
  184.               foundRecoil = true;
  185.               Object.defineProperty(Object.prototype, key, {
  186.                 get: () => {
  187.                   return espConfig.noRecoil ? 0 : item[key];
  188.                 },
  189.                 set: (baseRecoil) => {
  190.                   _baseRecoil = baseRecoil;
  191.                 }
  192.               });
  193.               break;
  194.             }
  195.           }
  196.         }
  197.       }
  198.     }
  199.     return Reflect.apply(...arguments);
  200.   }
  201. };
  202. Array.prototype.push = new Proxy(Array.prototype.push, arrayPushHandler);
  203.  
  204. // listen for mouse click
  205. let isLeftClick = false;
  206. let isRightClick = false;
  207. document.addEventListener('mousedown', (e) => {
  208.   if (e.button === 0) {
  209.     isLeftClick = true;
  210.   }
  211.   if (e.button === 2) {
  212.     if (espConfig.isSniper) {
  213.       setTimeout(() => {
  214.         isRightClick = true;
  215.       }, 400);
  216.     } else {
  217.       isRightClick = true;
  218.     }
  219.   }
  220. });
  221. document.addEventListener('mouseup', (e) => {
  222.   if (e.button === 0) {
  223.     isLeftClick = false;
  224.   }
  225.   if (e.button === 2) {
  226.     isRightClick = false;
  227.   }
  228. });
  229.  
  230. // obfuscaed keys
  231. let worldScene = null;
  232. let childrenKey = null;
  233. let worldCamera = null;
  234. let projectionMatrixKey = null;
  235. let matrixWorldKey = null;
  236. let matrixElKey = null;
  237.  
  238. // three.js setup
  239. const scene = new THREE.Scene();
  240. const camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 1000);
  241. camera.rotation.order = 'YXZ';
  242. let saveViewport = new THREE.Vector4();
  243. let saveScissor = new THREE.Vector4();
  244. let minimapViewport = new THREE.Vector4(20, window.innerHeight - 250 - 20, 250, 250);
  245. const minimapCamera = new THREE.OrthographicCamera(-espConfig.mapZoom, espConfig.mapZoom, espConfig.mapZoom, -espConfig.mapZoom, 0.1, 1000);
  246. minimapCamera.rotation.order = 'YXZ';
  247. minimapCamera.position.set(0, 50, 0);
  248. minimapCamera.lookAt(0, 0, 0);
  249. const renderer = new THREE.WebGLRenderer( {
  250.   alpha: true,
  251.   antialias: true
  252. });
  253. renderer.setSize(window.innerWidth, window.innerHeight);
  254. renderer.setPixelRatio(window.devicePixelRatio);
  255. renderer.domElement.id = 'overlayCanvas';
  256. document.body.appendChild(renderer.domElement);
  257.  
  258.  
  259. function setTransform(target, transform, isMatrix = true) {
  260.   const matrix = new THREE.Matrix4().fromArray(isMatrix ? transform : transform[matrixWorldKey][matrixElKey]);
  261.   matrix.decompose(target.position, target.quaternion, target.scale);
  262. }
  263.  
  264. doOnce = (fn) => {
  265.   let done = false;
  266.   return (...args) => {
  267.     if (!done) {
  268.       done = true;
  269.       return fn(...args);
  270.     }
  271.   };
  272. };
  273.  
  274. function checkWorldCamera(object) {
  275.   if (worldCamera && object.uuid === worldCamera.uuid) return;
  276.   let hasProjectionMatrix = false;
  277.   for (const key in object) {
  278.     const element = object[key];
  279.     if (!element) continue;
  280.     if (typeof element == 'object') {
  281.       if (hasProjectionMatrix) continue;
  282.       const valueKey = Object.keys(element)[0];
  283.       const value = element[valueKey];
  284.       if (Array.isArray(value) && value[11] === -1) {
  285.         hasProjectionMatrix = true;
  286.         matrixElKey = valueKey;
  287.         projectionMatrixKey = key;
  288.       }
  289.     } else if (typeof element === 'function') {
  290.       const code = element.toString();
  291.       const match = /verse'\]\(this\['([^']+)'\]\);/.exec(code);
  292.       if (match) {
  293.         matrixWorldKey = match[1];
  294.       }
  295.     }
  296.     if (hasProjectionMatrix && matrixWorldKey) {
  297.       console.log('Found camera', {object}, object);
  298.       worldCamera = object;
  299.       object[projectionMatrixKey] = new Proxy(object[projectionMatrixKey], {
  300.         get: function(target, prop, receiver) {
  301.           setTransform(camera, object, false);
  302.           camera.near = worldCamera.near;
  303.           camera.far = worldCamera.far;
  304.           camera.aspect = worldCamera.aspect;
  305.           camera.fov = worldCamera.fov;
  306.           camera.updateProjectionMatrix();
  307.           worldCamera = object;
  308.           window.worldCamera = object;
  309.           return Reflect.get(...arguments);
  310.         }
  311.       });
  312.       break;
  313.     }
  314.   }
  315. }
  316.  
  317. function checkWorldScene(object) {
  318.   if (worldScene || object instanceof THREE.Scene) return;
  319.   for (const key in object) {
  320.     const element = object[key];
  321.     if (!element) continue;
  322.     if (Array.isArray(element) && element.length === 9) {
  323.       const value = element[0];
  324.       if (value && typeof value === 'object' && value.hasOwnProperty('uuid')) {
  325.         childrenKey = key;
  326.       }
  327.     }
  328.     if (childrenKey) {
  329.       console.log('Found scene', {childrenKey}, object);
  330.       worldScene = object;
  331.       window.worldScene = object;
  332.       renderer.setAnimationLoop(animate);
  333.       break;
  334.     }
  335.   }
  336. }
  337.  
  338. Object.defineProperty( Object.prototype, 'overrideMaterial', {
  339.   get: function() {
  340.     checkWorldScene(this);
  341.     return this._overrideMaterial;
  342.   },
  343.   set: function(value) {
  344.     this._overrideMaterial = value;
  345.   }
  346. });
  347. Object.defineProperty( Object.prototype, 'far', {
  348.   get: function() {
  349.     checkWorldCamera(this);
  350.     return this._far;
  351.   },
  352.   set: function(value) {
  353.     this._far = value;
  354.   }
  355. });
  356.  
  357. function isPlayer(entity) {
  358.   try {
  359.     return entity[childrenKey].length > 2 || !entity[childrenKey][1].geometry;
  360.   } catch {
  361.     return false;
  362.   }
  363. }
  364.  
  365. // claim ads
  366. function claimAds() {
  367.   document.querySelectorAll('svg').forEach(svg => {
  368.     if (svg.getAttribute('data-icon') === 'play-circle') {
  369.       svg.closest('div').click();
  370.       console.log('Claimed ads');
  371.     }
  372.   });
  373. }
  374.  
  375. const context2DFillTextHandler = {
  376.   apply: function(target, thisArg, argumentsList) {
  377.     thisArg.canvas.lastText = argumentsList[0];
  378.     return Reflect.apply(...arguments);
  379.   }
  380. };
  381. CanvasRenderingContext2D.prototype.fillText = new Proxy(CanvasRenderingContext2D.prototype.fillText, context2DFillTextHandler);
  382.  
  383. function isEnnemy(entity) {
  384.   for (const child of entity[childrenKey]) {
  385.     try {
  386.       const matImage = child.material.map.image;
  387.       if (matImage instanceof HTMLCanvasElement && matImage.hasOwnProperty('lastText')) {
  388.         entity.playerName = matImage.lastText;
  389.         return false;
  390.       }
  391.     } catch {}
  392.   }
  393.   return true;
  394. }
  395.  
  396. function setFiring(shouldFire) {
  397.   if (setFiring.firing === shouldFire) return;
  398.   setFiring.firing = shouldFire;
  399.   if (shouldFire) {
  400.     if (espConfig.isSniper) { // need improvement
  401.       setTimeout(() => {
  402.         document.dispatchEvent(new MouseEvent('mousedown', { buttons: 3 }));
  403.         setTimeout(() => {
  404.           document.dispatchEvent(new MouseEvent('mouseup', { buttons: 0 }));
  405.         }, 200);
  406.         // setFiring.firing = false;
  407.       }, 300);
  408.     } else {
  409.       document.dispatchEvent(new MouseEvent('mousedown', { buttons: 3 }));
  410.     }
  411.   } else {
  412.     document.dispatchEvent(new MouseEvent('mouseup', { buttons: 0 }));
  413.   }
  414. }
  415.  
  416. const colors = {
  417.   ennemy: new THREE.Color(0xff0000),
  418.   player: new THREE.Color(0x00ff00),
  419.   blue: new THREE.Color(0x0000ff)
  420. };
  421.  
  422. const outlineMats = {
  423.   ennemy: new THREE.LineBasicMaterial({ color: colors.ennemy }),
  424.   player: new THREE.LineBasicMaterial({ color: colors.player })
  425. };
  426. const meshMats = {
  427.   ennemy: new THREE.MeshBasicMaterial({ color: colors.ennemy, transparent: true, opacity: 0.5 }),
  428.   player: new THREE.MeshBasicMaterial({ color: colors.player, transparent: true, opacity: 0.5 })
  429. };
  430.  
  431. const raycaster = new THREE.Raycaster();
  432. const edgesGeometry = new THREE.EdgesGeometry(new THREE.BoxGeometry(1, 1, 1).translate(0, 0.5, 0));
  433.  
  434.  
  435. const lineGeometry = new THREE.BufferGeometry();
  436. const lineMaterial = new THREE.LineBasicMaterial({ vertexColors: true, transparent: true });
  437. const line = new THREE.LineSegments(lineGeometry, lineMaterial);
  438. line.frustumCulled = false;
  439. scene.add(line);
  440.  
  441. const dummyLookAt = new THREE.PerspectiveCamera();
  442. const color = new THREE.Color();
  443.  
  444. const chunkMaterial = new THREE.MeshNormalMaterial();
  445.  
  446. const boxPlayerGeometry = new THREE.BoxGeometry(.25, 1.25, 0.25);
  447.  
  448.  
  449. // crosshair circle
  450. const crosshairGeometry = new THREE.CircleGeometry(.5, 32);
  451. const crosshairMaterial = new THREE.LineBasicMaterial({ color: 0xffffff, transparent: true, opacity: 0.2 });
  452. const crosshair = new THREE.LineLoop(crosshairGeometry, crosshairMaterial);
  453. camera.add(crosshair);
  454. scene.add(camera);
  455.  
  456. function calculateValue(maxAngleInRadians) {
  457.   const a = -79.83;
  458.   const b = -30.06;
  459.   const c = -0.90;
  460.   return a * Math.exp(b * maxAngleInRadians) + c;
  461. }
  462.  
  463. function animate(time) {
  464.   const now = Date.now();
  465.   const entities = childrenKey ? worldScene[childrenKey][5][childrenKey] : [];
  466.   const lineOrigin = camera.localToWorld(new THREE.Vector3(0, 0, -10));
  467.   const linePositions = [];
  468.   crosshair.position.z = calculateValue(espConfig.maxAngleInRadians);
  469.   crosshair.visible = espConfig.showAimRadius;
  470.   const colorArray = [];
  471.   const aimbotTarget = { angleDifference: Infinity};
  472.   const chunks = [];
  473.   const gameChunks = childrenKey ? worldScene[childrenKey][4][childrenKey] : [];
  474.   for (const chunk of gameChunks) {
  475.     if (!chunk || !chunk.geometry) continue;
  476.     const chunkPositions = chunk.geometry.attributes.position.array;
  477.     if (!chunkPositions || !chunkPositions.length) continue;
  478.     if (!chunk.myChunk) {
  479.       const geometry = new THREE.BufferGeometry();
  480.       geometry.setAttribute(
  481.         'position',
  482.         new THREE.Float32BufferAttribute(chunkPositions, 3)
  483.       );
  484.       geometry.setIndex(
  485.         new THREE.BufferAttribute(chunk.geometry.index.array, 1)
  486.       );
  487.       geometry.computeVertexNormals();
  488.       geometry.computeBoundingBox();
  489.       chunk.myChunk = new THREE.Mesh(geometry, chunkMaterial);
  490.       chunk.myChunk.box = new THREE.Box3();
  491.     }
  492.     const myChunk = chunk.myChunk;
  493.     if (chunk.material) chunk.material.wireframe = espConfig.wireframe;
  494.     setTransform(myChunk, chunk, false);
  495.     myChunk.updateMatrixWorld();
  496.     myChunk.box.copy(myChunk.geometry.boundingBox).applyMatrix4(myChunk.matrixWorld);
  497.     chunks.push(myChunk);
  498.   }
  499.  
  500.   chunks.sort((a, b) => {
  501.     const distanceA = a.position.distanceTo(camera.position);
  502.     const distanceB = b.position.distanceTo(camera.position);
  503.     return distanceB - distanceA;
  504.   });
  505.  
  506.   const shouldAimbot = espConfig.aimbot === 3 || (espConfig.aimbot === 1 && isLeftClick) || (espConfig.aimbot === 2 && isRightClick);
  507.  
  508.   entities.forEach(entity => {
  509.     if (!entity || !entity.parent) return;
  510.     if (!entity.myObject3D) {
  511.       entity.myObject3D = new THREE.Object3D();
  512.       entity.myObject3D.frustumCulled = false;
  513.       entity.discovered = now;
  514.       entity.loaded = false;
  515.       entity.logged = false;
  516.       entity.ennemy = null;
  517.       return;
  518.     }
  519.     if (typeof entity.visible === 'boolean' && !entity.visible) {
  520.       entity.myObject3D.visible = false;
  521.       return;
  522.     }
  523.     if (!entity.loaded && now - entity.discovered < 500) return;
  524.     entity.loaded = true;
  525.     if (!entity.logged && isPlayer(entity)) {
  526.       const skinnedMesh = entity[childrenKey][1][childrenKey][3];
  527.       entity.isPlayer = true;
  528.       entity.logged = true;
  529.       entity.ennemy = isEnnemy(entity);
  530.       const playerMesh = new THREE.Mesh(skinnedMesh.geometry, entity.ennemy ? meshMats.ennemy : meshMats.player);
  531.       entity.myObject3D.add(playerMesh);
  532.       entity.myObject3D.playerMesh = playerMesh;
  533.       const playerMiniMap = new THREE.Mesh(skinnedMesh.geometry, entity.ennemy ? meshMats.ennemy : meshMats.player);
  534.       playerMiniMap.visible = false;
  535.       entity.myObject3D.add(playerMiniMap);
  536.       entity.myObject3D.playerMiniMap = playerMiniMap;
  537.       const outline = new THREE.LineSegments(edgesGeometry, entity.ennemy ? outlineMats.ennemy : outlineMats.player);
  538.       outline.scale.set(0.5, 1.25, 0.5);
  539.       outline.frustumCulled = false;
  540.       entity.myObject3D.add(outline);
  541.       entity.myObject3D.outline = outline;
  542.       const boxMesh = new THREE.Mesh(boxPlayerGeometry, entity.ennemy ? meshMats.ennemy : meshMats.player);
  543.       boxMesh.position.y = 0.625;
  544.       entity.myObject3D.add(boxMesh);
  545.       entity.myObject3D.boxMesh = boxMesh;
  546.       const dir = new THREE.Vector3(0, 0, -1);
  547.       const origin = new THREE.Vector3(0, 1, 0);
  548.       const arrowLookingAt = new THREE.ArrowHelper(dir, origin, 1, entity.ennemy ? colors.ennemy : colors.player, 0.5, .4);
  549.       playerMiniMap.add(arrowLookingAt);
  550.       setTransform(entity.myObject3D, entity, false);
  551.       scene.add(entity.myObject3D);
  552.     }
  553.     if (entity.isPlayer) {
  554.       entity.myObject3D.playerMesh.rotation.y = -entity[childrenKey][1].rotation._y;
  555.       entity.myObject3D.playerMiniMap.rotation.y = -entity[childrenKey][1].rotation._y;
  556.       const skinnedMesh = entity[childrenKey][1][childrenKey][3];
  557.       const isSneak = skinnedMesh.skeleton.bones[4].rotation._x > 0.1;
  558.       entity.myObject3D.boxMesh.scale.set(1, isSneak ? .4 : 1, 1);
  559.       entity.myObject3D.outline.scale.set(0.5, isSneak ? .9 : 1.25, 0.5);
  560.       entity.myObject3D.playerMesh.scale.set(1, isSneak ? .7 : 1, 1);
  561.  
  562.       entity.myObject3D.visible = true;
  563.       entity.myObject3D.playerMesh.visible = espConfig.showPlayer === 2 || (espConfig.showPlayer === 1 && !entity.ennemy);
  564.       entity.myObject3D.boxMesh.visible = espConfig.showBox === 2 || (espConfig.showBox === 1 && entity.ennemy);
  565.       entity.myObject3D.outline.visible = espConfig.showOutline === 2 || (espConfig.showOutline === 1 && entity.ennemy);
  566.       setTransform(entity.myObject3D, entity, false);
  567.  
  568.       // aimbot and line
  569.       const pos = entity.myObject3D.position.clone();
  570.       pos.y -= isSneak ? espConfig.sneakHeight : 0;
  571.       // line
  572.       if (espConfig.showLine === 2 || (espConfig.showLine === 1 && entity.ennemy)) {
  573.         if (espConfig.rainbow) {
  574.           color.setHSL(time % 2000 / 2000, 1, 0.5);
  575.         } else if (entity.ennemy) {
  576.           color.lerpColors(colors.ennemy, colors.player, pos.distanceTo(camera.position) / espConfig.ennemyDistance);
  577.           color.a = .8;
  578.         } else {
  579.           color.set(colors.blue);
  580.           color.a = .3;
  581.         }
  582.         linePositions.push(lineOrigin.x, lineOrigin.y, lineOrigin.z);
  583.         pos.y += 1.25;
  584.         linePositions.push(pos.x, pos.y, pos.z);
  585.         pos.y -= 1.25;
  586.         colorArray.push(color.r, color.g, color.b, color.a);
  587.         colorArray.push(color.r, color.g, color.b, color.a);
  588.       }
  589.       pos.y += espConfig.heightLine;
  590.       // aimbot
  591.       if (shouldAimbot && (entity.ennemy || espConfig.allEnnemies)) {
  592.         const distance = pos.distanceTo(camera.position);
  593.         const target = pos.clone();
  594.         const dummy = new THREE.PerspectiveCamera();
  595.         setTransform(dummy, worldCamera, false);
  596.         dummy.lookAt(target);
  597.         const cameraVector = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion);
  598.         const targetVector = new THREE.Vector3(0, 0, -1).applyQuaternion(dummy.quaternion);
  599.         const angleDifference = cameraVector.angleTo(targetVector);
  600.         if (angleDifference < espConfig.maxAngleInRadians && angleDifference < aimbotTarget.angleDifference) {
  601.           const directionV3 = new THREE.Vector3();
  602.           directionV3.subVectors(target, camera.position).normalize();
  603.           raycaster.set(camera.position, directionV3);
  604.           let behindBlock = false;
  605.           if (espConfig.aimbotIgnoreWall) {
  606.             aimbotTarget.angleDifference = angleDifference;
  607.             aimbotTarget.target = target;
  608.           } else {
  609.             for (const chunk of chunks) {
  610.               if (raycaster.ray.intersectsBox(chunk.box)) {
  611.                 const hit = raycaster.intersectObject(chunk)[0];
  612.                 if (hit && hit.distance < distance) {
  613.                   behindBlock = true;
  614.                   break;
  615.                 }
  616.               }
  617.             }
  618.             if (!behindBlock) {
  619.               aimbotTarget.angleDifference = angleDifference;
  620.               aimbotTarget.target = target;
  621.               color.setHSL(time % 2000 / 2000, 1, 0.5);
  622.             }
  623.           }
  624.         }
  625.       }
  626.     }
  627.   });
  628.  
  629.   // aim at target
  630.   if (espConfig.aimbot && shouldAimbot && aimbotTarget.target) {
  631.     setTransform(dummyLookAt, worldCamera, false);
  632.     dummyLookAt.lookAt(aimbotTarget.target);
  633.     worldCamera.rotation.set(
  634.       dummyLookAt.rotation.x,
  635.       dummyLookAt.rotation.y,
  636.       dummyLookAt.rotation.z
  637.     );
  638.   }
  639.   // triggerbot
  640.   const shouldTrigger = espConfig.triggerBot === 3 || (espConfig.triggerBot === 1 && isLeftClick) || (espConfig.triggerBot === 2 && isRightClick);
  641.   if (shouldTrigger) {
  642.     raycaster.set(camera.position, camera.getWorldDirection(new THREE.Vector3()));
  643.     let hasHit = false;
  644.     for (const entity of entities) {
  645.       if (!entity.myObject3D.visible) continue;
  646.       if (entity.isPlayer && (entity.ennemy || espConfig.allEnnemies)) {
  647.         const hit = raycaster.intersectObject(entity.myObject3D.playerMesh);
  648.         if (hit.length) {
  649.           hasHit = true;
  650.           const distance = hit[0].distance;
  651.           for (const chunk of chunks) {
  652.             if (raycaster.ray.intersectsBox(chunk.box)) {
  653.               const hitBlock = raycaster.intersectObject(chunk)[0];
  654.               if (hitBlock && hitBlock.distance < distance) {
  655.                 hasHit = false;
  656.                 break;
  657.               }
  658.             }
  659.           }
  660.           if (hasHit) {
  661.             break;
  662.           }
  663.         }
  664.       }
  665.     }
  666.     setFiring(hasHit);
  667.   } else {
  668.     setFiring(false);
  669.   }
  670.  
  671.   line.geometry.setAttribute('color', new THREE.Float32BufferAttribute(colorArray, 4));
  672.   line.geometry.setAttribute('position', new THREE.Float32BufferAttribute(linePositions, 3));
  673.   line.visible = espConfig.showLine;
  674.  
  675.   renderer.render(scene, camera);
  676.  
  677.   // minimap
  678.   // make entities larger for minimap
  679.   const scale = espConfig.mapZoom / 3;
  680.   entities.forEach(entity => {
  681.     if (entity.isPlayer) {
  682.       entity.myObject3D.playerMesh.visible = false;
  683.       entity.myObject3D.boxMesh.visible = false;
  684.       entity.myObject3D.outline.visible = false;
  685.       entity.myObject3D.playerMiniMap.visible = true;
  686.       entity.myObject3D.playerMiniMap.scale.set(scale, 1, scale);
  687.     }
  688.   });
  689.   if (worldCamera) {
  690.     line.visible = false;
  691.     crosshair.visible = false;
  692.     // update orthographic camera based on espConfig.mapZoom
  693.     minimapCamera.left = -espConfig.mapZoom;
  694.     minimapCamera.right = espConfig.mapZoom;
  695.     minimapCamera.top = espConfig.mapZoom;
  696.     minimapCamera.bottom = -espConfig.mapZoom;
  697.  
  698.     // update position with camera position
  699.     minimapCamera.position.copy(camera.position);
  700.     minimapCamera.position.y += 50;
  701.     minimapCamera.position.z += espConfig.mapOffsetZ;
  702.     minimapCamera.rotation.y = camera.rotation.y;
  703.     minimapCamera.updateProjectionMatrix();
  704.  
  705.     renderer.getViewport(saveViewport);
  706.     renderer.getScissor(saveScissor);
  707.     let saveScissorTest = renderer.getScissorTest();
  708.     renderer.setViewport(minimapViewport);
  709.     renderer.setScissor(minimapViewport);
  710.     renderer.setScissorTest(true);
  711.  
  712.     renderer.render(scene, minimapCamera);
  713.  
  714.     renderer.setViewport(saveViewport);
  715.     renderer.setScissor(saveScissor);
  716.     renderer.setScissorTest(saveScissorTest);
  717.   }
  718.   entities.forEach(entity => {
  719.     if (entity.isPlayer) {
  720.       entity.myObject3D.playerMiniMap.visible = false;
  721.     }
  722.   });
  723.  
  724.   scene.children.forEach(child => {
  725.     if (child.type === 'Object3D') {
  726.       child.visible = false;
  727.     }
  728.   });
  729. }
  730.  
  731. window.addEventListener('resize', () => {
  732.   renderer.setSize( window.innerWidth, window.innerHeight );
  733. });
  734.  
  735. // add style to header
  736. style.innerHTML = `
  737. #overlayCanvas {
  738.   position: absolute;
  739.   top: 0;
  740.   left: 0;
  741.   width: 100%;
  742.   height: 100%;
  743.   pointer-events: none;
  744.   z-index: 1000;
  745. }
  746. #lil-gui {
  747.   position: absolute;
  748.   top: 50%;
  749.   right: 0;
  750.   z-index: 1001;
  751.   transform: translateY(-50%);
  752. }
  753. .lil-gui {
  754.   --background-color: rgba(0, 0, 0, 0.5);
  755. }
  756. `;
  757. guiStyle.innerHTML = `
  758. .lil-gui {
  759. 	--title-background-color: #ff0019;
  760. 	--number-color: #00ff33;
  761. }
  762. `;
  763. document.head.appendChild(style);
  764. document.head.appendChild(guiStyle);
  765.  
  766. // anti-afk
  767. setInterval(() => {
  768.   if (espConfig.antiAFK) {
  769.     // move left for .5s then right for .5s
  770.     document.dispatchEvent(new KeyboardEvent('keydown', { keyCode: 87}));
  771.     setTimeout(() => {
  772.       document.dispatchEvent(new KeyboardEvent('keyup', { keyCode: 87}));
  773.       document.dispatchEvent(new KeyboardEvent('keydown', { keyCode: 83}));
  774.       setTimeout(() => {
  775.         document.dispatchEvent(new KeyboardEvent('keyup', { keyCode: 83}));
  776.       }, 500);
  777.     }, 500);
  778.   }
  779. }, 5000);
  780.  
  781.  
  782. // wait for load
  783. window.addEventListener('load', () => {
  784.   console.log('Loaded');
  785.   if (espConfig.autoClaimAds) {
  786.     setTimeout(() => {
  787.       claimAds();
  788.     }, 500);
  789.   }
  790. });