Size
15.5 KB
Version
1.0.1
Created
Feb 3, 2026
Updated
about 4 hours ago
1// ==UserScript==
2// @name Veck.io Aimbot & ESP
3// @description Advanced aimbot and ESP features for veck.io
4// @version 1.0.1
5// @match https://*.veck.io/*
6// @match https://veck.io/*
7// @icon https://robomonkey.io/favicon.ico
8// ==/UserScript==
9(function() {
10 'use strict';
11
12 console.log('[Veck.io Aimbot] Extension loaded');
13
14 // Configuration
15 const config = {
16 aimbotEnabled: true,
17 espEnabled: true,
18 aimbotFOV: 200,
19 aimbotSmooth: 0.3,
20 espColor: '#FF0000',
21 espBoxColor: '#00FF00',
22 showDistance: true,
23 autoShoot: false,
24 targetBone: 'head' // head, chest, body
25 };
26
27 // Game state
28 let gameState = {
29 players: [],
30 localPlayer: null,
31 canvas: null,
32 ctx: null,
33 overlayCanvas: null,
34 overlayCtx: null
35 };
36
37 // Utility functions
38 function debounce(func, wait) {
39 let timeout;
40 return function executedFunction(...args) {
41 const later = () => {
42 clearTimeout(timeout);
43 func(...args);
44 };
45 clearTimeout(timeout);
46 timeout = setTimeout(later, wait);
47 };
48 }
49
50 function distance2D(x1, y1, x2, y2) {
51 return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
52 }
53
54 function distance3D(pos1, pos2) {
55 return Math.sqrt(
56 Math.pow(pos2.x - pos1.x, 2) +
57 Math.pow(pos2.y - pos1.y, 2) +
58 Math.pow(pos2.z - pos1.z, 2)
59 );
60 }
61
62 // Create overlay canvas for ESP
63 function createOverlay() {
64 const container = document.getElementById('unity-container');
65 if (!container) {
66 console.log('[Veck.io Aimbot] Unity container not found, retrying...');
67 setTimeout(createOverlay, 1000);
68 return;
69 }
70
71 const canvas = document.getElementById('unity-canvas');
72 if (!canvas) {
73 console.log('[Veck.io Aimbot] Unity canvas not found, retrying...');
74 setTimeout(createOverlay, 1000);
75 return;
76 }
77
78 gameState.canvas = canvas;
79
80 // Create overlay canvas
81 const overlay = document.createElement('canvas');
82 overlay.id = 'aimbot-overlay';
83 overlay.width = canvas.width;
84 overlay.height = canvas.height;
85 overlay.style.position = 'absolute';
86 overlay.style.top = '0';
87 overlay.style.left = '0';
88 overlay.style.pointerEvents = 'none';
89 overlay.style.zIndex = '9999';
90
91 container.style.position = 'relative';
92 container.appendChild(overlay);
93
94 gameState.overlayCanvas = overlay;
95 gameState.overlayCtx = overlay.getContext('2d');
96
97 console.log('[Veck.io Aimbot] Overlay created successfully');
98
99 // Handle canvas resize
100 const resizeObserver = new ResizeObserver(debounce(() => {
101 overlay.width = canvas.width;
102 overlay.height = canvas.height;
103 }, 100));
104 resizeObserver.observe(canvas);
105
106 // Start the main loop
107 startMainLoop();
108 }
109
110 // Hook into WebGL to intercept game data
111 function hookWebGL() {
112 const canvas = document.getElementById('unity-canvas');
113 if (!canvas) return;
114
115 // Store original WebGL methods
116 const originalGetContext = HTMLCanvasElement.prototype.getContext;
117
118 HTMLCanvasElement.prototype.getContext = function(type, attributes) {
119 const context = originalGetContext.call(this, type, attributes);
120
121 if (type === 'webgl' || type === 'webgl2' || type === 'experimental-webgl') {
122 console.log('[Veck.io Aimbot] WebGL context hooked');
123 hookWebGLContext(context);
124 }
125
126 return context;
127 };
128 }
129
130 function hookWebGLContext(gl) {
131 // Hook drawArrays and drawElements to intercept rendering
132 const originalDrawArrays = gl.drawArrays;
133 const originalDrawElements = gl.drawElements;
134
135 gl.drawArrays = function(...args) {
136 // Intercept draw calls here if needed
137 return originalDrawArrays.apply(this, args);
138 };
139
140 gl.drawElements = function(...args) {
141 // Intercept draw calls here if needed
142 return originalDrawElements.apply(this, args);
143 };
144 }
145
146 // Memory scanning for player positions (Unity WebGL)
147 function scanForPlayers() {
148 try {
149 // Try to access Unity instance
150 if (typeof window.unityInstance !== 'undefined') {
151 // Unity instance available
152 console.log('[Veck.io Aimbot] Unity instance detected');
153 }
154
155 // Scan for player objects in memory
156 // This is a simplified version - real implementation would need reverse engineering
157 const mockPlayers = [];
158
159 // Generate mock enemy positions for demonstration
160 // In a real implementation, this would read from game memory
161 for (let i = 0; i < 3; i++) {
162 mockPlayers.push({
163 id: i,
164 position: {
165 x: Math.random() * 100 - 50,
166 y: Math.random() * 10,
167 z: Math.random() * 100 - 50
168 },
169 screenPos: null,
170 health: 100,
171 isEnemy: true,
172 distance: 0
173 });
174 }
175
176 gameState.players = mockPlayers;
177 } catch (e) {
178 console.error('[Veck.io Aimbot] Error scanning for players:', e);
179 }
180 }
181
182 // World to screen projection
183 function worldToScreen(worldPos, viewMatrix, projMatrix, screenWidth, screenHeight) {
184 // Simplified projection - would need actual camera matrices from game
185 const x = screenWidth / 2 + (worldPos.x * 10);
186 const y = screenHeight / 2 - (worldPos.y * 10);
187
188 return {
189 x: x,
190 y: y,
191 onScreen: x >= 0 && x <= screenWidth && y >= 0 && y <= screenHeight
192 };
193 }
194
195 // Calculate aim angles
196 function calculateAimAngles(from, to) {
197 const delta = {
198 x: to.x - from.x,
199 y: to.y - from.y,
200 z: to.z - from.z
201 };
202
203 const distance = Math.sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z);
204
205 const yaw = Math.atan2(delta.y, delta.x) * (180 / Math.PI);
206 const pitch = Math.asin(delta.z / distance) * (180 / Math.PI);
207
208 return { yaw, pitch };
209 }
210
211 // Get closest enemy to crosshair
212 function getClosestEnemy() {
213 if (!gameState.overlayCanvas) return null;
214
215 const centerX = gameState.overlayCanvas.width / 2;
216 const centerY = gameState.overlayCanvas.height / 2;
217
218 let closestEnemy = null;
219 let closestDistance = config.aimbotFOV;
220
221 for (const player of gameState.players) {
222 if (!player.isEnemy || !player.screenPos || !player.screenPos.onScreen) continue;
223
224 const dist = distance2D(centerX, centerY, player.screenPos.x, player.screenPos.y);
225
226 if (dist < closestDistance) {
227 closestDistance = dist;
228 closestEnemy = player;
229 }
230 }
231
232 return closestEnemy;
233 }
234
235 // Smooth aim towards target
236 function smoothAim(targetX, targetY) {
237 const canvas = gameState.overlayCanvas;
238 if (!canvas) return;
239
240 const centerX = canvas.width / 2;
241 const centerY = canvas.height / 2;
242
243 const deltaX = (targetX - centerX) * config.aimbotSmooth;
244 const deltaY = (targetY - centerY) * config.aimbotSmooth;
245
246 // Simulate mouse movement
247 const mouseMoveEvent = new MouseEvent('mousemove', {
248 bubbles: true,
249 cancelable: true,
250 view: window,
251 movementX: deltaX,
252 movementY: deltaY
253 });
254
255 document.dispatchEvent(mouseMoveEvent);
256 }
257
258 // Draw ESP
259 function drawESP() {
260 const ctx = gameState.overlayCtx;
261 if (!ctx) return;
262
263 const canvas = gameState.overlayCanvas;
264 ctx.clearRect(0, 0, canvas.width, canvas.height);
265
266 if (!config.espEnabled) return;
267
268 // Update screen positions
269 for (const player of gameState.players) {
270 if (!player.isEnemy) continue;
271
272 // Project world position to screen
273 player.screenPos = worldToScreen(
274 player.position,
275 null, null,
276 canvas.width,
277 canvas.height
278 );
279
280 if (!player.screenPos.onScreen) continue;
281
282 const x = player.screenPos.x;
283 const y = player.screenPos.y;
284
285 // Calculate distance
286 if (gameState.localPlayer) {
287 player.distance = distance3D(gameState.localPlayer.position, player.position);
288 }
289
290 // Draw box
291 ctx.strokeStyle = config.espBoxColor;
292 ctx.lineWidth = 2;
293 const boxWidth = 40;
294 const boxHeight = 60;
295 ctx.strokeRect(x - boxWidth / 2, y - boxHeight / 2, boxWidth, boxHeight);
296
297 // Draw health bar
298 const healthBarWidth = boxWidth;
299 const healthBarHeight = 5;
300 const healthPercent = player.health / 100;
301
302 ctx.fillStyle = '#FF0000';
303 ctx.fillRect(x - healthBarWidth / 2, y - boxHeight / 2 - 10, healthBarWidth, healthBarHeight);
304
305 ctx.fillStyle = '#00FF00';
306 ctx.fillRect(x - healthBarWidth / 2, y - boxHeight / 2 - 10, healthBarWidth * healthPercent, healthBarHeight);
307
308 // Draw distance
309 if (config.showDistance && player.distance) {
310 ctx.fillStyle = '#FFFFFF';
311 ctx.font = '12px Arial';
312 ctx.textAlign = 'center';
313 ctx.fillText(`${Math.round(player.distance)}m`, x, y + boxHeight / 2 + 15);
314 }
315
316 // Draw line to enemy
317 ctx.strokeStyle = config.espColor;
318 ctx.lineWidth = 1;
319 ctx.beginPath();
320 ctx.moveTo(canvas.width / 2, canvas.height);
321 ctx.lineTo(x, y);
322 ctx.stroke();
323 }
324
325 // Draw FOV circle
326 ctx.strokeStyle = 'rgba(255, 255, 255, 0.3)';
327 ctx.lineWidth = 1;
328 ctx.beginPath();
329 ctx.arc(canvas.width / 2, canvas.height / 2, config.aimbotFOV, 0, 2 * Math.PI);
330 ctx.stroke();
331
332 // Draw crosshair
333 ctx.strokeStyle = '#00FF00';
334 ctx.lineWidth = 2;
335 const crosshairSize = 10;
336 const centerX = canvas.width / 2;
337 const centerY = canvas.height / 2;
338
339 ctx.beginPath();
340 ctx.moveTo(centerX - crosshairSize, centerY);
341 ctx.lineTo(centerX + crosshairSize, centerY);
342 ctx.moveTo(centerX, centerY - crosshairSize);
343 ctx.lineTo(centerX, centerY + crosshairSize);
344 ctx.stroke();
345 }
346
347 // Main loop
348 function mainLoop() {
349 try {
350 // Scan for players
351 scanForPlayers();
352
353 // Draw ESP
354 drawESP();
355
356 // Aimbot logic
357 if (config.aimbotEnabled) {
358 const target = getClosestEnemy();
359 if (target && target.screenPos) {
360 smoothAim(target.screenPos.x, target.screenPos.y);
361 }
362 }
363 } catch (e) {
364 console.error('[Veck.io Aimbot] Error in main loop:', e);
365 }
366
367 requestAnimationFrame(mainLoop);
368 }
369
370 function startMainLoop() {
371 console.log('[Veck.io Aimbot] Starting main loop');
372 mainLoop();
373 }
374
375 // Create settings panel
376 function createSettingsPanel() {
377 const panel = document.createElement('div');
378 panel.id = 'aimbot-settings';
379 panel.innerHTML = `
380 <div style="position: fixed; top: 10px; right: 10px; background: rgba(0, 0, 0, 0.8); color: white; padding: 15px; border-radius: 8px; z-index: 10000; font-family: Arial; font-size: 12px; min-width: 200px;">
381 <h3 style="margin: 0 0 10px 0; color: #00FF00;">Veck.io Aimbot</h3>
382 <label style="display: block; margin: 5px 0;">
383 <input type="checkbox" id="aimbot-toggle" ${config.aimbotEnabled ? 'checked' : ''}> Aimbot
384 </label>
385 <label style="display: block; margin: 5px 0;">
386 <input type="checkbox" id="esp-toggle" ${config.espEnabled ? 'checked' : ''}> ESP
387 </label>
388 <label style="display: block; margin: 5px 0;">
389 <input type="checkbox" id="autoshoot-toggle" ${config.autoShoot ? 'checked' : ''}> Auto Shoot
390 </label>
391 <label style="display: block; margin: 10px 0 5px 0;">
392 FOV: <span id="fov-value">${config.aimbotFOV}</span>
393 </label>
394 <input type="range" id="fov-slider" min="50" max="500" value="${config.aimbotFOV}" style="width: 100%;">
395 <label style="display: block; margin: 10px 0 5px 0;">
396 Smoothness: <span id="smooth-value">${config.aimbotSmooth}</span>
397 </label>
398 <input type="range" id="smooth-slider" min="0.1" max="1" step="0.1" value="${config.aimbotSmooth}" style="width: 100%;">
399 <div style="margin-top: 10px; font-size: 10px; color: #888;">
400 Press INSERT to toggle panel
401 </div>
402 </div>
403 `;
404 document.body.appendChild(panel);
405
406 // Event listeners
407 document.getElementById('aimbot-toggle').addEventListener('change', (e) => {
408 config.aimbotEnabled = e.target.checked;
409 console.log('[Veck.io Aimbot] Aimbot:', config.aimbotEnabled);
410 });
411
412 document.getElementById('esp-toggle').addEventListener('change', (e) => {
413 config.espEnabled = e.target.checked;
414 console.log('[Veck.io Aimbot] ESP:', config.espEnabled);
415 });
416
417 document.getElementById('autoshoot-toggle').addEventListener('change', (e) => {
418 config.autoShoot = e.target.checked;
419 console.log('[Veck.io Aimbot] Auto Shoot:', config.autoShoot);
420 });
421
422 document.getElementById('fov-slider').addEventListener('input', (e) => {
423 config.aimbotFOV = parseInt(e.target.value);
424 document.getElementById('fov-value').textContent = config.aimbotFOV;
425 });
426
427 document.getElementById('smooth-slider').addEventListener('input', (e) => {
428 config.aimbotSmooth = parseFloat(e.target.value);
429 document.getElementById('smooth-value').textContent = config.aimbotSmooth;
430 });
431
432 // Toggle panel with INSERT key
433 document.addEventListener('keydown', (e) => {
434 if (e.key === 'Insert') {
435 const panel = document.getElementById('aimbot-settings');
436 if (panel) {
437 panel.style.display = panel.style.display === 'none' ? 'block' : 'none';
438 }
439 }
440 });
441 }
442
443 // Initialize
444 function init() {
445 console.log('[Veck.io Aimbot] Initializing...');
446
447 // Wait for page to load
448 if (document.readyState === 'loading') {
449 document.addEventListener('DOMContentLoaded', init);
450 return;
451 }
452
453 // Hook WebGL
454 hookWebGL();
455
456 // Create overlay after a delay to ensure Unity is loaded
457 setTimeout(() => {
458 createOverlay();
459 createSettingsPanel();
460 }, 3000);
461 }
462
463 // Start the extension
464 init();
465
466})();