☰

1v1.LOL Ultimate Aimbot, ESP & Wireframe View

Advanced aimbot system with customizable settings for 1v1.LOL players.

// ==UserScript==  
// @name         1v1.LOL Ultimate Aimbot, ESP & Wireframe View  
// @namespace    http://tampermonkey.net/  
// @version      3.2  
// @description  Advanced aimbot system with customizable settings for 1v1.LOL players.  
// @author       Optimized by AI  
// @match        *://1v1.lol/*  
// @match        *://1v1.school/*  
// @grant        none  
// @run-at       document-start  
// ==/UserScript==

const config = {
    aimbot: false,
    aimbotSpeed: 0.2,
    aimbotFOV: 45,
    prioritizeHead: true,
    esp: true,
    wireframe: false,
    guiEnabled: true,
    detectionRadius: 300,
    createdBy: 'Advanced AI',
    aimbotType: 'tracking',
    aimbotSmoothness: 0.5,
    aimbotTriggerKey: 'KeyT',
    espColor: '#FF0000',
    wireframeColor: '#00FF00',
};

let targetData = {
    x: 0,
    y: 0,
    active: false,
};

// Initialize GUI using dat.GUI
function initializeGUI() {
    const gui = new dat.GUI();
    gui.add(config, 'aimbot').name('Aimbot').onChange(updateSettings);
    gui.add(config, 'aimbotSpeed', 0.05, 0.5, 0.01).name('Aimbot Speed').onChange(updateSettings);
    gui.add(config, 'aimbotFOV', 10, 180, 5).name('Aimbot FOV').onChange(updateSettings);
    gui.add(config, 'prioritizeHead').name('Prioritize Head').onChange(updateSettings);
    gui.add(config, 'esp').name('ESP').onChange(updateSettings);
    gui.add(config, 'wireframe').name('Wireframe').onChange(updateSettings);
    gui.add(config, 'detectionRadius', 100, 500, 10).name('Detection Radius').onChange(updateSettings);
    gui.add(config, 'guiEnabled').name('Enable GUI');
    gui.add(config, 'aimbotType', ['tracking', 'injection', 'aimassist', 'triggerbot']).name('Aimbot Type').onChange(updateSettings);
    gui.add(config, 'aimbotSmoothness', 0.1, 1.0, 0.1).name('Aimbot Smoothness').onChange(updateSettings);
    gui.add(config, 'aimbotTriggerKey').name('Aimbot Trigger Key').onChange(updateSettings);
    gui.addColor(config, 'espColor').name('ESP Color').onChange(updateSettings);
    gui.addColor(config, 'wireframeColor').name('Wireframe Color').onChange(updateSettings);
}

// Aimbot logic
function aimbotLogic() {
    if (!config.aimbot) return;

    const gl = getWebGLContext();
    if (!gl) return;

    const width = Math.min(config.detectionRadius, gl.canvas.width);
    const height = Math.min(config.detectionRadius, gl.canvas.height);
    const pixels = new Uint8Array(width * height * 4);

    const centerX = gl.canvas.width / 2;
    const centerY = gl.canvas.height / 2;

    const x = Math.floor(centerX - width / 2);
    const y = Math.floor(centerY - height / 2);

    gl.readPixels(x, y, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);

    let closestDistance = Infinity;
    let targetX = 0;
    let targetY = 0;

    for (let i = 0; i < pixels.length; i += 4) {
        const r = pixels[i], g = pixels[i + 1], b = pixels[i + 2], a = pixels[i + 3];
        if (r === 255 && g === 0 && b === 0 && a === 255) {
            const idx = i / 4;
            const dx = (idx % width) - width / 2;
            const dy = Math.floor(idx / width) - height / 2;
            const distance = Math.sqrt(dx * dx + dy * dy);

            if (distance < closestDistance && distance < (config.aimbotFOV * width) / gl.canvas.width) {
                closestDistance = distance;
                targetX = dx;
                targetY = dy;
            }
        }
    }

    if (closestDistance < Infinity) {
        targetData = {
            x: targetX,
            y: targetY,
            active: true,
        };
    } else {
        targetData.active = false;
    }
}

// Smooth aiming
function smoothAim() {
    if (!targetData.active) return;

    const movementX = targetData.x * config.aimbotSpeed * config.aimbotSmoothness;
    const movementY = -targetData.y * config.aimbotSpeed * config.aimbotSmoothness;

    window.dispatchEvent(new MouseEvent('mousemove', { movementX, movementY }));
}

// Key listeners for toggling features
function addKeyListeners() {
    window.addEventListener('keyup', (event) => {
        if (document.activeElement && document.activeElement.tagName === 'INPUT') return;

        switch (event.code) {
            case 'KeyM':
                toggleFeature('esp');
                break;
            case 'KeyN':
                toggleFeature('wireframe');
                break;
            case config.aimbotTriggerKey:
                toggleFeature('aimbot');
                break;
        }
    });
}

// Toggle features
function toggleFeature(feature) {
    config[feature] = !config[feature];
    showNotification(`${feature} is now ${config[feature] ? 'enabled' : 'disabled'}`);
}

// Show notifications
function showNotification(message) {
    const notification = document.createElement('div');
    Object.assign(notification.style, {
        position: 'absolute',
        top: '10px',
        right: '10px',
        padding: '10px',
        background: 'rgba(0, 0, 0, 0.7)',
        color: '#fff',
        borderRadius: '5px',
        zIndex: 9999,
        fontSize: '14px',
        pointerEvents: 'none',
    });
    notification.textContent = message;
    document.body.appendChild(notification);
    setTimeout(() => notification.remove(), 2000);
}

// Get WebGL Context
function getWebGLContext() {
    const canvas = document.querySelector('canvas');
    if (!canvas) {
        console.warn("Canvas element not found.");
        return null;
    }

    const gl = canvas.getContext('webgl2');
    if (!gl) {
        console.error("WebGL2 context unavailable.");
    }
    return gl;
}

// Update settings callback
function updateSettings() {
    console.log('Settings updated:', config);
}

// Main initialization
function initAimbot() {
    try {
        initializeGUI();
        addKeyListeners();

        function loop() {
            aimbotLogic();
            smoothAim();
            requestAnimationFrame(loop);
        }
        loop();
    } catch (error) {
        console.error("Initialization error:", error);
    }
}

initAimbot();