☰

WormVision Lite MAX – Full ESP + Aimbot UI (CloudSafe/Chromebook)

Chromebook-safe Fortnite ESP + Head Detection + FOV + Smooth Aimbot + Triggerbot | Runs on Xbox Cloud Gaming 🎯💻🧠

  1. // ==UserScript==
  2. // @name         WormVision Lite MAX – Full ESP + Aimbot UI (CloudSafe/Chromebook)
  3. // @namespace    http://wormgpt.blacklightrift
  4. // @version      1.2
  5. // @description  Chromebook-safe Fortnite ESP + Head Detection + FOV + Smooth Aimbot + Triggerbot | Runs on Xbox Cloud Gaming 🎯💻🧠
  6. // @author       Worm
  7. // @match        *://*.xbox.com/*
  8. // @grant        none
  9. // ==/UserScript==
  10.  
  11. (function () {
  12.     'use strict';
  13.  
  14.     ///////////////////////////////
  15.     // === UI & STYLE SYSTEM === //
  16.     ///////////////////////////////
  17.  
  18.     const style = document.createElement('style');
  19.     style.innerHTML = `
  20.         .worm-ui {
  21.             position: fixed;
  22.             top: 20px;
  23.             right: 20px;
  24.             width: 280px;
  25.             background: #0e0e12;
  26.             border: 2px solid #8f00ff;
  27.             border-radius: 12px;
  28.             color: white;
  29.             font-family: Arial, sans-serif;
  30.             font-size: 14px;
  31.             z-index: 999999;
  32.             padding: 12px;
  33.             box-shadow: 0 0 12px #8f00ff88;
  34.             display: none;
  35.         }
  36.         .worm-ui h2 {
  37.             margin: 0 0 10px;
  38.             font-size: 16px;
  39.             text-align: center;
  40.             color: #BB86FC;
  41.         }
  42.         .worm-ui label {
  43.             display: flex;
  44.             justify-content: space-between;
  45.             margin: 6px 0;
  46.         }
  47.         .worm-ui input[type=checkbox], .worm-ui input[type=range] {
  48.             transform: scale(1.2);
  49.         }
  50.         .worm-overlay, .worm-head {
  51.             position: fixed;
  52.             z-index: 999998;
  53.             pointer-events: none;
  54.         }
  55.         .worm-box {
  56.             border: 2px solid lime;
  57.             background: rgba(0, 255, 0, 0.1);
  58.             border-radius: 4px;
  59.         }
  60.         .worm-head {
  61.             width: 6px;
  62.             height: 6px;
  63.             background: red;
  64.             border-radius: 50%;
  65.         }
  66.         .worm-fov {
  67.             border: 2px dashed rgba(255, 0, 255, 0.6);
  68.             border-radius: 50%;
  69.         }
  70.     `;
  71.     document.head.appendChild(style);
  72.  
  73.     const uiHTML = `
  74.         <div class="worm-ui" id="wormMenu">
  75.             <h2>🧠 WormVision Lite MAX</h2>
  76.             <label>ESP <input type="checkbox" id="esp-toggle"></label>
  77.             <label>Triggerbot <input type="checkbox" id="trigger-toggle"></label>
  78.             <label>Soft Aim <input type="checkbox" id="aim-toggle"></label>
  79.             <label>FOV Overlay <input type="checkbox" id="fov-toggle"></label>
  80.             <label>Aim Smooth<input type="range" id="smooth-slider" min="1" max="10" value="4"></label>
  81.         </div>
  82.     `;
  83.     document.body.insertAdjacentHTML('beforeend', uiHTML);
  84.     const menu = document.getElementById('wormMenu');
  85.  
  86.     // === Toggle Menu With Ctrl+Alt+G+3
  87.     let buffer = [];
  88.     window.addEventListener('keydown', e => {
  89.         buffer.push(e.key.toLowerCase());
  90.         if (buffer.length > 5) buffer.shift();
  91.         if (buffer.join('-').includes('control-alt-g-3')) {
  92.             menu.style.display = menu.style.display === 'none' ? 'block' : 'none';
  93.             buffer = [];
  94.         }
  95.     });
  96.  
  97.     ///////////////////////////
  98.     // === STATE + LOGIC === //
  99.     ///////////////////////////
  100.  
  101.     const config = {
  102.         esp: false,
  103.         triggerbot: false,
  104.         aim: false,
  105.         fov: false,
  106.         smoothness: 4,
  107.         aimKey: 'f',
  108.         aimRadius: 100,
  109.     };
  110.  
  111.     document.getElementById('esp-toggle').addEventListener('change', e => config.esp = e.target.checked);
  112.     document.getElementById('trigger-toggle').addEventListener('change', e => config.triggerbot = e.target.checked);
  113.     document.getElementById('aim-toggle').addEventListener('change', e => config.aim = e.target.checked);
  114.     document.getElementById('fov-toggle').addEventListener('change', e => config.fov = e.target.checked);
  115.     document.getElementById('smooth-slider').addEventListener('input', e => config.smoothness = parseInt(e.target.value));
  116.  
  117.     let aimX = 0, aimY = 0;
  118.  
  119.     function drawESP(x, y, w, h, scaleX, scaleY) {
  120.         const box = document.createElement('div');
  121.         box.className = 'worm-overlay worm-box';
  122.         box.style.left = `${x * scaleX}px`;
  123.         box.style.top = `${y * scaleY}px`;
  124.         box.style.width = `${w * scaleX}px`;
  125.         box.style.height = `${h * scaleY}px`;
  126.         document.body.appendChild(box);
  127.         setTimeout(() => box.remove(), 80);
  128.     }
  129.  
  130.     function drawHead(x, y, scaleX, scaleY) {
  131.         const dot = document.createElement('div');
  132.         dot.className = 'worm-head';
  133.         dot.style.left = `${x * scaleX}px`;
  134.         dot.style.top = `${y * scaleY}px`;
  135.         document.body.appendChild(dot);
  136.         setTimeout(() => dot.remove(), 80);
  137.     }
  138.  
  139.     function drawFOV() {
  140.         const fov = document.createElement('div');
  141.         const size = config.aimRadius * 2;
  142.         fov.className = 'worm-overlay worm-fov';
  143.         fov.style.width = `${size}px`;
  144.         fov.style.height = `${size}px`;
  145.         fov.style.left = `calc(50% - ${config.aimRadius}px)`;
  146.         fov.style.top = `calc(50% - ${config.aimRadius}px)`;
  147.         document.body.appendChild(fov);
  148.         setTimeout(() => fov.remove(), 80);
  149.     }
  150.  
  151.     ///////////////////////////////
  152.     // === VISION / AIM ENGINE ===
  153.     ///////////////////////////////
  154.  
  155.     function lerp(a, b, t) {
  156.         return a + (b - a) * t;
  157.     }
  158.  
  159.     function scanFrame() {
  160.         const video = document.querySelector('video');
  161.         if (!video || video.videoWidth === 0) return;
  162.  
  163.         const canvas = document.createElement('canvas');
  164.         canvas.width = video.videoWidth;
  165.         canvas.height = video.videoHeight;
  166.         const ctx = canvas.getContext('2d');
  167.  
  168.         try {
  169.             ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
  170.             const pixels = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
  171.             const centerX = canvas.width / 2;
  172.             const centerY = canvas.height / 2;
  173.             const targets = [];
  174.  
  175.             for (let y = 0; y < canvas.height; y += 6) {
  176.                 for (let x = 0; x < canvas.width; x += 6) {
  177.                     const idx = (y * canvas.width + x) * 4;
  178.                     const r = pixels[idx], g = pixels[idx + 1], b = pixels[idx + 2];
  179.  
  180.                     if ((r > 200 && g < 80 && b < 80) || (r > 200 && g > 200 && b > 200)) {
  181.                         targets.push({ x, y });
  182.                     }
  183.                 }
  184.             }
  185.  
  186.             const clusters = groupByProximity(targets, 40);
  187.             const scaleX = window.innerWidth / canvas.width;
  188.             const scaleY = window.innerHeight / canvas.height;
  189.             let best = null;
  190.             let bestDist = Infinity;
  191.  
  192.             clusters.forEach(cluster => {
  193.                 const minX = Math.min(...cluster.map(p => p.x));
  194.                 const minY = Math.min(...cluster.map(p => p.y));
  195.                 const maxX = Math.max(...cluster.map(p => p.x));
  196.                 const maxY = Math.max(...cluster.map(p => p.y));
  197.  
  198.                 const width = maxX - minX;
  199.                 const height = maxY - minY;
  200.                 const headX = minX + width / 2;
  201.                 const headY = minY;
  202.  
  203.                 if (config.esp) drawESP(minX, minY, width, height, scaleX, scaleY);
  204.                 if (config.esp) drawHead(headX, headY, scaleX, scaleY);
  205.  
  206.                 const dx = headX - centerX;
  207.                 const dy = headY - centerY;
  208.                 const dist = Math.sqrt(dx * dx + dy * dy);
  209.  
  210.                 if (dist < bestDist && dist < config.aimRadius) {
  211.                     best = { dx, dy };
  212.                     bestDist = dist;
  213.                 }
  214.             });
  215.  
  216.             // Triggerbot
  217.             if (config.triggerbot) {
  218.                 const mid = ctx.getImageData(centerX, centerY, 1, 1).data;
  219.                 if (mid[0] > 200 && mid[1] < 80 && mid[2] < 80) {
  220.                     document.dispatchEvent(new KeyboardEvent('keydown', { key: config.aimKey, bubbles: true }));
  221.                     document.dispatchEvent(new KeyboardEvent('keyup', { key: config.aimKey, bubbles: true }));
  222.                 }
  223.             }
  224.  
  225.             // Aim assist
  226.             if (config.aim && best) {
  227.                 aimX = lerp(aimX, best.dx, 1 / config.smoothness);
  228.                 aimY = lerp(aimY, best.dy, 1 / config.smoothness);
  229.                 window.dispatchEvent(new MouseEvent('mousemove', {
  230.                     movementX: aimX / 4,
  231.                     movementY: aimY / 4,
  232.                     bubbles: true
  233.                 }));
  234.             }
  235.  
  236.             if (config.fov) drawFOV();
  237.  
  238.         } catch (err) {
  239.             // Ignore CORS errors
  240.         }
  241.     }
  242.  
  243.     function groupByProximity(points, threshold = 40) {
  244.         const groups = [];
  245.         points.forEach(p => {
  246.             let added = false;
  247.             for (let g of groups) {
  248.                 if (g.some(q => Math.hypot(p.x - q.x, p.y - q.y) < threshold)) {
  249.                     g.push(p);
  250.                     added = true;
  251.                     break;
  252.                 }
  253.             }
  254.             if (!added) groups.push([p]);
  255.         });
  256.         return groups.filter(g => g.length > 5);
  257.     }
  258.  
  259.     setInterval(scanFrame, 70);
  260. })();