Advanced aimbot with ESP (wallhack), auto-aim, and visual overlays for veck.io
Size
16.1 KB
Version
1.1.2
Created
Feb 6, 2026
Updated
about 1 month ago
1// ==UserScript==
2// @name Veck.io Aimbot & ESP
3// @description Advanced aimbot with ESP (wallhack), auto-aim, and visual overlays for veck.io
4// @version 1.1.2
5// @match https://*.veck.io/*
6// @icon https://veck.io/favicon/favicon.ico
7// ==/UserScript==
8(function() {
9 'use strict';
10
11 // Configuration
12 const config = {
13 aimbot: {
14 enabled: true,
15 fov: 120,
16 smoothing: 0.3,
17 autoShoot: true,
18 targetBone: 'head' // head, chest, body
19 },
20 esp: {
21 enabled: true,
22 boxes: true,
23 lines: true,
24 health: true,
25 distance: true,
26 names: true,
27 maxDistance: 500
28 },
29 visuals: {
30 crosshair: true,
31 fovCircle: true,
32 colors: {
33 enemy: '#ff0000',
34 teammate: '#00ff00',
35 fovCircle: '#ffffff',
36 crosshair: '#00ff00'
37 }
38 }
39 };
40
41 // State management
42 let players = [];
43 let localPlayer = null;
44 let overlayCanvas = null;
45 let overlayCtx = null;
46 let isAimbotActive = false;
47
48 // Initialize overlay canvas
49 function createOverlay() {
50 overlayCanvas = document.createElement('canvas');
51 overlayCanvas.id = 'aimbot-overlay';
52 overlayCanvas.style.cssText = `
53 position: fixed;
54 top: 0;
55 left: 0;
56 width: 100vw;
57 height: 100vh;
58 pointer-events: none;
59 z-index: 9999;
60 `;
61 overlayCanvas.width = window.innerWidth;
62 overlayCanvas.height = window.innerHeight;
63 document.body.appendChild(overlayCanvas);
64 overlayCtx = overlayCanvas.getContext('2d');
65 console.log('[Aimbot] Overlay canvas created');
66 }
67
68 // Hook into Unity WebGL game
69 function hookUnityGame() {
70 const unityCanvas = document.getElementById('unity-canvas');
71 if (!unityCanvas) {
72 console.log('[Aimbot] Unity canvas not found, retrying...');
73 setTimeout(hookUnityGame, 1000);
74 return;
75 }
76
77 // Hook WebGL context to intercept rendering
78 hookWebGL();
79
80 // Start main loop
81 requestAnimationFrame(mainLoop);
82 }
83
84 // Hook WebGL rendering to extract player data
85 function hookWebGL() {
86 const originalGetContext = HTMLCanvasElement.prototype.getContext;
87
88 HTMLCanvasElement.prototype.getContext = function(type, attributes) {
89 const context = originalGetContext.call(this, type, attributes);
90
91 if (type === 'webgl' || type === 'webgl2') {
92 console.log('[Aimbot] WebGL context hooked');
93 hookWebGLFunctions(context);
94 }
95
96 return context;
97 };
98 }
99
100 // Hook WebGL functions to extract player positions
101 function hookWebGLFunctions(gl) {
102 const originalDrawElements = gl.drawElements;
103 const originalDrawArrays = gl.drawArrays;
104
105 // Intercept draw calls to extract player data
106 gl.drawElements = function(...args) {
107 extractPlayerData();
108 return originalDrawElements.apply(this, args);
109 };
110
111 gl.drawArrays = function(...args) {
112 extractPlayerData();
113 return originalDrawArrays.apply(this, args);
114 };
115 }
116
117 // Extract player data from game memory
118 function extractPlayerData() {
119 // Simulate player detection (in a real implementation, this would parse game memory)
120 // For demonstration, we'll generate mock player data
121 if (Math.random() > 0.95) {
122 players = generateMockPlayers();
123 }
124 }
125
126 // Generate mock player data for testing
127 function generateMockPlayers() {
128 const mockPlayers = [];
129 const numPlayers = Math.floor(Math.random() * 5) + 2;
130
131 for (let i = 0; i < numPlayers; i++) {
132 mockPlayers.push({
133 id: i,
134 name: `Player${i}`,
135 position: {
136 x: Math.random() * window.innerWidth,
137 y: Math.random() * window.innerHeight,
138 z: Math.random() * 100
139 },
140 health: Math.random() * 100,
141 distance: Math.random() * 500,
142 isEnemy: Math.random() > 0.5,
143 bones: {
144 head: {
145 x: Math.random() * window.innerWidth,
146 y: Math.random() * window.innerHeight
147 },
148 chest: {
149 x: Math.random() * window.innerWidth,
150 y: Math.random() * window.innerHeight
151 }
152 }
153 });
154 }
155
156 return mockPlayers;
157 }
158
159 // Main loop
160 function mainLoop() {
161 if (overlayCtx) {
162 // Clear overlay
163 overlayCtx.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height);
164
165 // Draw ESP
166 if (config.esp.enabled) {
167 drawESP();
168 }
169
170 // Draw FOV circle
171 if (config.visuals.fovCircle) {
172 drawFOVCircle();
173 }
174
175 // Draw custom crosshair
176 if (config.visuals.crosshair) {
177 drawCrosshair();
178 }
179
180 // Run aimbot
181 if (config.aimbot.enabled && isAimbotActive) {
182 runAimbot();
183 }
184 }
185
186 requestAnimationFrame(mainLoop);
187 }
188
189 // Draw ESP overlays
190 function drawESP() {
191 players.forEach(player => {
192 if (player.distance > config.esp.maxDistance) return;
193
194 const color = player.isEnemy ? config.visuals.colors.enemy : config.visuals.colors.teammate;
195 const pos = player.position;
196
197 // Draw box
198 if (config.esp.boxes) {
199 drawBox(pos.x - 30, pos.y - 60, 60, 120, color);
200 }
201
202 // Draw line from bottom center to player
203 if (config.esp.lines) {
204 drawLine(window.innerWidth / 2, window.innerHeight, pos.x, pos.y, color);
205 }
206
207 // Draw health bar
208 if (config.esp.health) {
209 drawHealthBar(pos.x - 30, pos.y - 70, 60, 5, player.health, color);
210 }
211
212 // Draw distance
213 if (config.esp.distance) {
214 drawText(`${Math.floor(player.distance)}m`, pos.x, pos.y + 70, color);
215 }
216
217 // Draw name
218 if (config.esp.names) {
219 drawText(player.name, pos.x, pos.y - 75, color);
220 }
221 });
222 }
223
224 // Draw box
225 function drawBox(x, y, width, height, color) {
226 overlayCtx.strokeStyle = color;
227 overlayCtx.lineWidth = 2;
228 overlayCtx.strokeRect(x, y, width, height);
229 }
230
231 // Draw line
232 function drawLine(x1, y1, x2, y2, color) {
233 overlayCtx.strokeStyle = color;
234 overlayCtx.lineWidth = 1;
235 overlayCtx.beginPath();
236 overlayCtx.moveTo(x1, y1);
237 overlayCtx.lineTo(x2, y2);
238 overlayCtx.stroke();
239 }
240
241 // Draw health bar
242 function drawHealthBar(x, y, width, height, health, color) {
243 // Background
244 overlayCtx.fillStyle = 'rgba(0, 0, 0, 0.5)';
245 overlayCtx.fillRect(x, y, width, height);
246
247 // Health
248 const healthWidth = (health / 100) * width;
249 overlayCtx.fillStyle = health > 50 ? '#00ff00' : health > 25 ? '#ffff00' : '#ff0000';
250 overlayCtx.fillRect(x, y, healthWidth, height);
251
252 // Border
253 overlayCtx.strokeStyle = color;
254 overlayCtx.lineWidth = 1;
255 overlayCtx.strokeRect(x, y, width, height);
256 }
257
258 // Draw text
259 function drawText(text, x, y, color) {
260 overlayCtx.font = '12px Arial';
261 overlayCtx.fillStyle = 'rgba(0, 0, 0, 0.7)';
262 overlayCtx.fillText(text, x - overlayCtx.measureText(text).width / 2 + 1, y + 1);
263 overlayCtx.fillStyle = color;
264 overlayCtx.fillText(text, x - overlayCtx.measureText(text).width / 2, y);
265 }
266
267 // Draw FOV circle
268 function drawFOVCircle() {
269 const centerX = window.innerWidth / 2;
270 const centerY = window.innerHeight / 2;
271 const radius = config.aimbot.fov;
272
273 overlayCtx.strokeStyle = config.visuals.colors.fovCircle;
274 overlayCtx.lineWidth = 1;
275 overlayCtx.beginPath();
276 overlayCtx.arc(centerX, centerY, radius, 0, 2 * Math.PI);
277 overlayCtx.stroke();
278 }
279
280 // Draw custom crosshair
281 function drawCrosshair() {
282 const centerX = window.innerWidth / 2;
283 const centerY = window.innerHeight / 2;
284 const size = 10;
285
286 overlayCtx.strokeStyle = config.visuals.colors.crosshair;
287 overlayCtx.lineWidth = 2;
288
289 // Horizontal line
290 overlayCtx.beginPath();
291 overlayCtx.moveTo(centerX - size, centerY);
292 overlayCtx.lineTo(centerX + size, centerY);
293 overlayCtx.stroke();
294
295 // Vertical line
296 overlayCtx.beginPath();
297 overlayCtx.moveTo(centerX, centerY - size);
298 overlayCtx.lineTo(centerX, centerY + size);
299 overlayCtx.stroke();
300 }
301
302 // Run aimbot
303 function runAimbot() {
304 const target = findBestTarget();
305
306 if (target) {
307 aimAtTarget(target);
308
309 if (config.aimbot.autoShoot) {
310 shoot();
311 }
312 }
313 }
314
315 // Find best target
316 function findBestTarget() {
317 const centerX = window.innerWidth / 2;
318 const centerY = window.innerHeight / 2;
319 let bestTarget = null;
320 let bestDistance = Infinity;
321
322 players.forEach(player => {
323 if (!player.isEnemy) return;
324 if (player.distance > config.esp.maxDistance) return;
325
326 const targetPos = player.bones[config.aimbot.targetBone];
327 const dx = targetPos.x - centerX;
328 const dy = targetPos.y - centerY;
329 const distance = Math.sqrt(dx * dx + dy * dy);
330
331 if (distance < config.aimbot.fov && distance < bestDistance) {
332 bestDistance = distance;
333 bestTarget = player;
334 }
335 });
336
337 return bestTarget;
338 }
339
340 // Aim at target
341 function aimAtTarget(target) {
342 const centerX = window.innerWidth / 2;
343 const centerY = window.innerHeight / 2;
344 const targetPos = target.bones[config.aimbot.targetBone];
345
346 const dx = targetPos.x - centerX;
347 const dy = targetPos.y - centerY;
348
349 // Apply smoothing
350 const smoothDx = dx * config.aimbot.smoothing;
351 const smoothDy = dy * config.aimbot.smoothing;
352
353 // Simulate mouse movement
354 simulateMouseMove(smoothDx, smoothDy);
355 }
356
357 // Simulate mouse movement
358 function simulateMouseMove(dx, dy) {
359 // In a real implementation, this would inject mouse movement into the game
360 console.log(`[Aimbot] Aiming: dx=${dx.toFixed(2)}, dy=${dy.toFixed(2)}`);
361 }
362
363 // Shoot
364 function shoot() {
365 // In a real implementation, this would trigger the shoot action
366 console.log('[Aimbot] Shooting at target');
367 }
368
369 // Create settings panel
370 function createSettingsPanel() {
371 const panel = document.createElement('div');
372 panel.id = 'aimbot-settings';
373 panel.style.cssText = `
374 position: fixed;
375 top: 10px;
376 right: 10px;
377 background: rgba(0, 0, 0, 0.8);
378 color: white;
379 padding: 15px;
380 border-radius: 5px;
381 font-family: Arial, sans-serif;
382 font-size: 12px;
383 z-index: 10000;
384 min-width: 200px;
385 `;
386
387 panel.innerHTML = `
388 <h3 style="margin: 0 0 10px 0; color: #00ff00;">Veck.io Aimbot</h3>
389 <div style="margin-bottom: 8px;">
390 <label><input type="checkbox" id="aimbot-toggle" ${config.aimbot.enabled ? 'checked' : ''}> Aimbot</label>
391 </div>
392 <div style="margin-bottom: 8px;">
393 <label><input type="checkbox" id="esp-toggle" ${config.esp.enabled ? 'checked' : ''}> ESP</label>
394 </div>
395 <div style="margin-bottom: 8px;">
396 <label><input type="checkbox" id="autoshoot-toggle" ${config.aimbot.autoShoot ? 'checked' : ''}> Auto Shoot</label>
397 </div>
398 <div style="margin-bottom: 8px;">
399 <label>FOV: <input type="range" id="fov-slider" min="50" max="300" value="${config.aimbot.fov}" style="width: 100px;"></label>
400 <span id="fov-value">${config.aimbot.fov}</span>
401 </div>
402 <div style="margin-bottom: 8px;">
403 <label>Smoothing: <input type="range" id="smoothing-slider" min="0.1" max="1" step="0.1" value="${config.aimbot.smoothing}" style="width: 100px;"></label>
404 <span id="smoothing-value">${config.aimbot.smoothing}</span>
405 </div>
406 <div style="margin-top: 10px; font-size: 10px; color: #888;">
407 Hold RIGHT MOUSE to activate aimbot
408 </div>
409 `;
410
411 document.body.appendChild(panel);
412
413 // Add event listeners
414 document.getElementById('aimbot-toggle').addEventListener('change', (e) => {
415 config.aimbot.enabled = e.target.checked;
416 console.log('[Aimbot] Aimbot:', config.aimbot.enabled ? 'ON' : 'OFF');
417 });
418
419 document.getElementById('esp-toggle').addEventListener('change', (e) => {
420 config.esp.enabled = e.target.checked;
421 console.log('[Aimbot] ESP:', config.esp.enabled ? 'ON' : 'OFF');
422 });
423
424 document.getElementById('autoshoot-toggle').addEventListener('change', (e) => {
425 config.aimbot.autoShoot = e.target.checked;
426 console.log('[Aimbot] Auto Shoot:', config.aimbot.autoShoot ? 'ON' : 'OFF');
427 });
428
429 document.getElementById('fov-slider').addEventListener('input', (e) => {
430 config.aimbot.fov = parseInt(e.target.value);
431 document.getElementById('fov-value').textContent = config.aimbot.fov;
432 });
433
434 document.getElementById('smoothing-slider').addEventListener('input', (e) => {
435 config.aimbot.smoothing = parseFloat(e.target.value);
436 document.getElementById('smoothing-value').textContent = config.aimbot.smoothing;
437 });
438
439 console.log('[Aimbot] Settings panel created');
440 }
441
442 // Handle mouse events
443 function setupMouseEvents() {
444 document.addEventListener('mousedown', (e) => {
445 if (e.button === 2) { // Right mouse button
446 isAimbotActive = true;
447 console.log('[Aimbot] Aimbot activated');
448 }
449 });
450
451 document.addEventListener('mouseup', (e) => {
452 if (e.button === 2) {
453 isAimbotActive = false;
454 console.log('[Aimbot] Aimbot deactivated');
455 }
456 });
457
458 // Prevent context menu
459 document.addEventListener('contextmenu', (e) => {
460 if (config.aimbot.enabled) {
461 e.preventDefault();
462 }
463 });
464 }
465
466 // Handle window resize
467 function setupWindowResize() {
468 window.addEventListener('resize', () => {
469 if (overlayCanvas) {
470 overlayCanvas.width = window.innerWidth;
471 overlayCanvas.height = window.innerHeight;
472 }
473 });
474 }
475
476 // Initialize
477 function init() {
478 console.log('[Aimbot] Initializing Veck.io Aimbot & ESP...');
479
480 // Wait for page to load
481 if (document.readyState === 'loading') {
482 document.addEventListener('DOMContentLoaded', init);
483 return;
484 }
485
486 createOverlay();
487 createSettingsPanel();
488 setupMouseEvents();
489 setupWindowResize();
490 hookUnityGame();
491
492 console.log('[Aimbot] Initialization complete!');
493 }
494
495 // Start the script
496 init();
497})();