cloud gaming cheat v3

// Enhanced Virtual Xbox Controller with Smooth Aim Assist and Advanced Features
class VirtualController {
    constructor() {
        this.axes = [0, 0, 0, 0];
        this.buttons = Array(17).fill().map(() => ({ pressed: false, value: 0 }));
        this.connected = true;
        this.id = "Virtual Xbox Controller (Enhanced Pro)";
        this.index = 0;
        this.timestamp = performance.now();
        this.mapping = "standard";
        this.vibrationActuator = {
            type: "dual-rumble",
            startDelay: 0,
            strongMagnitude: 0,
            weakMagnitude: 0
        };
    }

    update(timestamp) {
        this.timestamp = timestamp;
        return this;
    }
}

// Main Application Class
class GameControllerEnhancer {
    constructor() {
        // Controller state
        this.virtualController = new VirtualController();
        this.controllerInitialized = false;
        this.aimAssistEnabled = true;

        // Input state with advanced smoothing
        this.moveX = 0;
        this.moveY = 0;
        this.aimX = 0;
        this.aimY = 0;
        this.targetAimX = 0;
        this.targetAimY = 0;
        this.currentAimX = 0;
        this.currentAimY = 0;
        this.aimSmoothing = 0.2;
        this.aimAcceleration = 1.5;
        this.aimCurveFactor = 0.7; // New: Adds non-linear response curve

        // Feature toggles
        this.ultraLowDelay = false;
        this.highBitrate = false;
        this.zoomIn = false;
        this.crosshairOn = false;
        this.speedHack = false;
        this.zoomOut = false;
        this.zoomMore = false;
        this.macroEnabled = false;
        this.guiVisible = true;
        this.volumeBoost = false;
        this.performanceMode = false;

        // Macro configuration
        this.editBindKey = null;
        this.selectEditBindKey = null;
        this.configuringMacro = false;
        this.waitingForEditBind = false;
        this.waitingForSelectEditBind = false;
        this.macroActive = false;

        // Audio state
        this.audioContext = null;
        this.gainNode = null;
        this.bassFilter = null;
        this.audioSource = null;

        // UI elements
        this.gui = null;
        this.miniIndicator = null;
        this.enhancedCrosshair = null;
        this.notificationElement = null;

        // Performance tracking
        this.lastInputTime = 0;
        this.lastUpdateTime = 0;
        this.frameCount = 0;
        this.fps = 0;

        // Initialize everything
        this.init();
    }

    init() {
        this.setupAudio();
        this.createUI();
        this.overrideGamepadAPI();
        this.setupEventListeners();
        this.startUpdateLoop();

        // Show welcome notification
        this.showNotification("Cheat Activated", 3000);
    }

    // ========================
    // Core Functionality
    // ========================

    overrideGamepadAPI() {
        const originalGetGamepads = navigator.getGamepads;

        navigator.getGamepads = () => {
            const gamepads = Object.create(Array.prototype);

            if (this.aimAssistEnabled) {
                Object.defineProperty(gamepads, '0', {
                    enumerable: true,
                    value: this.virtualController.update(performance.now())
                });
            }

            for (let i = this.aimAssistEnabled ? 1 : 0; i < 4; i++) {
                Object.defineProperty(gamepads, i.toString(), {
                    enumerable: true,
                    value: null
                });
            }

            gamepads.length = 4;
            return gamepads;
        };
    }

    updateController() {
        // Apply non-linear response curve to aim inputs
        const applyResponseCurve = (value) => {
            return Math.sign(value) * Math.pow(Math.abs(value), this.aimCurveFactor);
        };

        // Smooth aiming with acceleration and response curve
        if (Math.abs(this.targetAimX - this.currentAimX) > 0.01 ||
            Math.abs(this.targetAimY - this.currentAimY) > 0.01) {

            const distX = this.targetAimX - this.currentAimX;
            const distY = this.targetAimY - this.currentAimY;

            const accelX = Math.sign(distX) * Math.min(
                Math.abs(distX) * this.aimAcceleration,
                Math.abs(distX)
            );
            const accelY = Math.sign(distY) * Math.min(
                Math.abs(distY) * this.aimAcceleration,
                Math.abs(distY)
            );

            this.currentAimX += accelX * this.aimSmoothing;
            this.currentAimY += accelY * this.aimSmoothing;
        }

        // Update controller axes with curved response
        this.virtualController.axes[0] = applyResponseCurve(this.moveX);
        this.virtualController.axes[1] = applyResponseCurve(this.moveY);
        this.virtualController.axes[2] = applyResponseCurve(this.currentAimX);
        this.virtualController.axes[3] = applyResponseCurve(this.currentAimY);

        // Initialize controller if needed
        if (this.aimAssistEnabled && !this.controllerInitialized) {
            this.initializeController();
        }
    }

    initializeController() {
        const connectEvent = new Event('gamepadconnected');
        Object.defineProperty(connectEvent, 'gamepad', {
            value: this.virtualController
        });
        window.dispatchEvent(connectEvent);
        this.controllerInitialized = true;
        this.showNotification("Virtual Controller Connected", 2000);
    }

    // ========================
    // Audio Enhancements
    // ========================

    setupAudio() {
        try {
            this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
            this.gainNode = this.audioContext.createGain();
            this.gainNode.gain.value = 1;

            this.bassFilter = this.audioContext.createBiquadFilter();
            this.bassFilter.type = 'lowshelf';
            this.bassFilter.frequency.value = 200;
            this.bassFilter.gain.value = 0;

            // Try to hook to video element first
            const videoHookAttempt = () => {
                const video = document.querySelector('video');
                if (video) {
                    this.audioSource = this.audioContext.createMediaElementSource(video);
                    this.audioSource.connect(this.gainNode)
                                     .connect(this.bassFilter)
                                     .connect(this.audioContext.destination);
                    this.showNotification("Audio Hooked to Video Element", 2000);
                    return true;
                }
                return false;
            };

            // Fallback to tab capture if no video found
            const tabCaptureFallback = () => {
                if (navigator.mediaDevices?.getUserMedia) {
                    navigator.mediaDevices.getUserMedia({ audio: true })
                        .then(stream => {
                            this.audioSource = this.audioContext.createMediaStreamSource(stream);
                            this.audioSource.connect(this.gainNode)
                                             .connect(this.bassFilter)
                                             .connect(this.audioContext.destination);
                            this.showNotification("Audio Hooked via Tab Capture", 2000);
                        })
                        .catch(e => {
                            console.error("Tab capture failed:", e);
                            this.showNotification("Audio Hook Failed", 2000, true);
                        });
                }
            };

            // Initial attempt
            if (!videoHookAttempt()) {
                // Schedule periodic attempts and final fallback
                const videoCheckInterval = setInterval(() => {
                    if (videoHookAttempt()) {
                        clearInterval(videoCheckInterval);
                    }
                }, 500);

                setTimeout(() => {
                    clearInterval(videoCheckInterval);
                    tabCaptureFallback();
                }, 5000);
            }
        } catch (e) {
            console.error("Audio setup failed:", e);
            this.showNotification("Audio Setup Failed", 2000, true);
        }
    }

    toggleVolumeBoost() {
        this.volumeBoost = !this.volumeBoost;

        if (this.gainNode && this.bassFilter) {
            this.gainNode.gain.value = this.volumeBoost ? 2.5 : 1;
            this.bassFilter.gain.value = this.volumeBoost ? 15 : 0;

            this.showNotification(
                `Volume Boost ${this.volumeBoost ? "ON" : "OFF"}`,
                1500
            );
        } else {
            this.showNotification("Audio Not Hooked Yet", 1500, true);
        }
    }

    // ========================
    // Performance Features
    // ========================

    setupKeepAlive() {
        if (!this._keepAliveAudio) {
            this._keepAliveAudio = new Audio('data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQAAAAA=');
            this._keepAliveAudio.loop = true;
            this._keepAliveAudio.volume = 0.01;

            this._keepAliveCanvas = document.createElement('canvas');
            this._keepAliveCanvas.style.cssText = 'position:absolute; top:-9999px; left:-9999px;';
            document.body.appendChild(this._keepAliveCanvas);
            this._keepAliveCtx = this._keepAliveCanvas.getContext('2d');
        }

        if (this.ultraLowDelay) {
            this._keepAliveAudio.play().catch(e => console.log("Keep-alive audio:", e.message));

            if (!this._keepAliveAnimation) {
                const animateKeepAlive = () => {
                    this._keepAliveCtx.clearRect(0, 0, 1, 1);
                    this._keepAliveCtx.fillStyle = '#000';
                    this._keepAliveCtx.fillRect(0, 0, 1, 1);
                    this.virtualController.update(performance.now());

                    if (this.ultraLowDelay) {
                        this._keepAliveAnimation = requestAnimationFrame(animateKeepAlive);
                    }
                };
                this._keepAliveAnimation = requestAnimationFrame(animateKeepAlive);
            }
        } else {
            this._keepAliveAudio.pause();

            if (this._keepAliveAnimation) {
                cancelAnimationFrame(this._keepAliveAnimation);
                this._keepAliveAnimation = null;
            }
        }
    }

    togglePerformanceMode() {
        this.performanceMode = !this.performanceMode;

        if (this.performanceMode) {
            // Apply performance optimizations
            document.body.classList.add('performance-mode');
            this.showNotification("Performance Mode ON", 2000);
        } else {
            // Revert optimizations
            document.body.classList.remove('performance-mode');
            this.showNotification("Performance Mode OFF", 2000);
        }
    }

    // ========================
    // Macro System
    // ========================

    executeMacro() {
        if (!this.macroEnabled || !this.editBindKey || !this.selectEditBindKey) return;

        const targetElement = document.activeElement || document.body;
        const dispatchKeyEvent = (type, key) => {
            const event = new KeyboardEvent(type, {
                key,
                code: `Key${key.toUpperCase()}`,
                keyCode: key.toUpperCase().charCodeAt(0),
                bubbles: true,
                cancelable: true
            });
            targetElement.dispatchEvent(event);
        };

        // Ultra-fast sequence with precise timing
        dispatchKeyEvent('keydown', this.editBindKey);

        setTimeout(() => {
            dispatchKeyEvent('keydown', this.selectEditBindKey);

            // Simulate click at screen center
            const clickEvent = new MouseEvent('click', {
                button: 0,
                buttons: 1,
                clientX: window.innerWidth / 2,
                clientY: window.innerHeight / 2,
                bubbles: true,
                cancelable: true
            });
            targetElement.dispatchEvent(clickEvent);

            setTimeout(() => {
                dispatchKeyEvent('keyup', this.editBindKey);
                dispatchKeyEvent('keyup', this.selectEditBindKey);
                this.showNotification("Macro Executed", 1000);
            }, 20);
        }, 5);
    }

    configureMacro() {
        if (!this.macroEnabled) return;

        if (!this.editBindKey) {
            this.waitingForEditBind = true;
            this.waitingForSelectEditBind = false;
            this.showNotification("Press Edit Key...", 3000);
            this.updateGUIDisplay();
            return;
        }

        if (!this.selectEditBindKey) {
            this.waitingForEditBind = false;
            this.waitingForSelectEditBind = true;
            this.showNotification("Press Select Key...", 3000);
            this.updateGUIDisplay();
            return;
        }

        this.waitingForEditBind = false;
        this.waitingForSelectEditBind = false;
        this.showNotification(`Macro Set: ${this.editBindKey}+${this.selectEditBindKey}`, 3000);
        this.updateGUIDisplay();
    }

    // ========================
    // Video Enhancements
    // ========================

    updateVideoStyle() {
        const videos = document.querySelectorAll('video');

        videos.forEach(video => {
            // Apply high bitrate enhancements
            if (this.highBitrate) {
                video.style.filter = 'contrast(115%) saturate(105%) brightness(102%)';
                video.style.imageRendering = 'crisp-edges';
                video.style.willChange = 'transform, filter';
            } else {
                video.style.filter = '';
                video.style.imageRendering = 'auto';
            }

            // Apply zoom level
            let scale = 1;
            if (this.zoomMore) scale = 2;
            else if (this.zoomIn) scale = 1.5;
            else if (this.zoomOut) scale = 0.75;

            video.style.transform = `scale(${scale})`;
            video.style.transition = this.ultraLowDelay ?
                'transform 0.05s linear' :
                'transform 0.1s ease';
            video.style.backfaceVisibility = 'hidden';
            video.style.transformStyle = 'preserve-3d';
        });
    }

    // ========================
    // User Interface
    // ========================

    createUI() {
        // Main GUI Panel
        this.gui = document.createElement('div');
        this.gui.id = 'game-controller-gui';
        this.gui.style.cssText = `
            position: fixed;
            top: 10px;
            right: 10px;
            background: rgba(20, 20, 25, 0.95);
            color: #e0e0e0;
            padding: 12px;
            z-index: 9999;
            font-family: 'Segoe UI', Arial, sans-serif;
            border-radius: 8px;
            box-shadow: 0 4px 15px rgba(0,0,0,0.3);
            border: 1px solid rgba(255,255,255,0.1);
            width: 280px;
            backdrop-filter: blur(8px);
            transition: all 0.2s ease;
        `;

        // Mini Indicator
        this.miniIndicator = document.createElement('div');
        this.miniIndicator.id = 'mini-indicator';
        this.miniIndicator.style.cssText = `
            position: fixed;
            top: 10px;
            right: 10px;
            background: rgba(20, 20, 25, 0.9);
            color: #00ffaa;
            padding: 6px 12px;
            z-index: 9998;
            font-family: 'Segoe UI', Arial, sans-serif;
            border-radius: 6px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
            font-size: 12px;
            display: none;
            border: 1px solid rgba(0,255,170,0.3);
            backdrop-filter: blur(4px);
        `;
        this.miniIndicator.innerHTML = 'Cheat [END]';

        // Enhanced Crosshair
        this.enhancedCrosshair = document.createElement('div');
        this.enhancedCrosshair.id = 'enhanced-crosshair';
        this.enhancedCrosshair.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            width: 24px;
            height: 24px;
            transform: translate(-50%, -50%);
            z-index: 9997;
            pointer-events: none;
            display: none;
        `;
        this.enhancedCrosshair.innerHTML = `
            <div style="position:absolute; top:50%; left:0; width:100%; height:2px; background:rgba(0,255,170,0.8); transform:translateY(-50%);"></div>
            <div style="position:absolute; top:0; left:50%; width:2px; height:100%; background:rgba(0,255,170,0.8); transform:translateX(-50%);"></div>
            <div style="position:absolute; top:50%; left:50%; width:6px; height:6px; background:rgba(255,50,50,0.9); border-radius:50%; transform:translate(-50%, -50%);"></div>
            <div style="position:absolute; top:50%; left:50%; width:12px; height:12px; border:2px solid rgba(0,255,170,0.5); border-radius:50%; transform:translate(-50%, -50%);"></div>
        `;

        // Notification Element
        this.notificationElement = document.createElement('div');
        this.notificationElement.id = 'controller-notification';
        this.notificationElement.style.cssText = `
            position: fixed;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            background: rgba(20, 20, 30, 0.9);
            color: white;
            padding: 10px 20px;
            border-radius: 6px;
            z-index: 9999;
            font-family: 'Segoe UI', Arial, sans-serif;
            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
            opacity: 0;
            transition: opacity 0.3s ease;
            pointer-events: none;
            border: 1px solid rgba(0,255,170,0.3);
            backdrop-filter: blur(4px);
            max-width: 80%;
            text-align: center;
        `;

        // Add all elements to the DOM
        document.body.appendChild(this.gui);
        document.body.appendChild(this.miniIndicator);
        document.body.appendChild(this.enhancedCrosshair);
        document.body.appendChild(this.notificationElement);

        // Initial GUI update
        this.updateGUIDisplay();
    }

    showNotification(message, duration = 2000, isError = false) {
        const notification = this.notificationElement;

        if (isError) {
            notification.style.color = '#ff5555';
            notification.style.borderColor = 'rgba(255,85,85,0.3)';
        } else {
            notification.style.color = 'white';
            notification.style.borderColor = 'rgba(0,255,170,0.3)';
        }

        notification.textContent = message;
        notification.style.opacity = '1';

        setTimeout(() => {
            notification.style.opacity = '0';
        }, duration);
    }

    updateGUIDisplay() {
        const macroStatus = this.macroEnabled ?
            (this.waitingForEditBind ? 'PRESS EDIT KEY' :
             this.waitingForSelectEditBind ? 'PRESS SELECT KEY' :
             this.editBindKey && this.selectEditBindKey ?
                `SET (${this.editBindKey}+${this.selectEditBindKey})` : 'ON') :
            'OFF';

        this.gui.innerHTML = `
            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
                <h3 style="margin: 0; font-size: 16px; color: #00ffaa; font-weight: 600;">XCloud Cheat</h3>
                <div style="font-size: 11px; color: #aaa;">FPS: ${this.fps}</div>
            </div>

            <div style="height: 1px; background: linear-gradient(to right, transparent, rgba(0,255,170,0.3), transparent); margin: 8px 0;"></div>

            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 8px;">
                <!-- Column 1 -->
                <div>
                    <div class="gui-item">
                        <span>Ultra Low Delay [I]</span>
                        <span style="color: ${this.ultraLowDelay ? '#00ffaa' : '#ff5555'}">
                            ${this.ultraLowDelay ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>High Bitrate [O]</span>
                        <span style="color: ${this.highBitrate ? '#00ffaa' : '#ff5555'}">
                            ${this.highBitrate ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Zoom In [P]</span>
                        <span style="color: ${this.zoomIn ? '#00ffaa' : '#ff5555'}">
                            ${this.zoomIn ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Zoom Out [L]</span>
                        <span style="color: ${this.zoomOut ? '#00ffaa' : '#ff5555'}">
                            ${this.zoomOut ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Zoom 2x [;]</span>
                        <span style="color: ${this.zoomMore ? '#00ffaa' : '#ff5555'}">
                            ${this.zoomMore ? 'ON' : 'OFF'}
                        </span>
                    </div>
                </div>

                <!-- Column 2 -->
                <div>
                    <div class="gui-item">
                        <span>Crosshair [K]</span>
                        <span style="color: ${this.crosshairOn ? '#00ffaa' : '#ff5555'}">
                            ${this.crosshairOn ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Speed Hack [U]</span>
                        <span style="color: ${this.speedHack ? '#00ffaa' : '#ff5555'}">
                            ${this.speedHack ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Controller [J]</span>
                        <span style="color: ${this.aimAssistEnabled ? '#00ffaa' : '#ff5555'}">
                            ${this.aimAssistEnabled ? 'ON' : 'OFF'}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Macro [M]</span>
                        <span style="color: ${this.macroEnabled ? '#00ffaa' : '#ff5555'}">
                            ${macroStatus}
                        </span>
                    </div>

                    <div class="gui-item">
                        <span>Perf Mode [F1]</span>
                        <span style="color: ${this.performanceMode ? '#00ffaa' : '#ff5555'}">
                            ${this.performanceMode ? 'ON' : 'OFF'}
                        </span>
                    </div>
                </div>
            </div>

            <div style="height: 1px; background: linear-gradient(to right, transparent, rgba(0,255,170,0.3), transparent); margin: 8px 0;"></div>

            <div style="font-size: 12px; color: #aaa; line-height: 1.4;">
                <div>Hold <span style="color: #00ffaa;">V</span> for Volume Boost</div>
                <div>Press <span style="color: #00ffaa;">G</span> to trigger macro</div>
                <div>Press <span style="color: #00ffaa;">END</span> to toggle UI</div>
            </div>
        `;

        // Add some CSS for the items
        const style = document.createElement('style');
        style.textContent = `
            .gui-item {
                display: flex;
                justify-content: space-between;
                margin-bottom: 6px;
                font-size: 13px;
            }
            .gui-item span:first-child {
                color: #ccc;
            }
            #game-controller-gui:hover {
                transform: translateY(-2px);
                box-shadow: 0 6px 20px rgba(0,0,0,0.4);
            }
        `;
        this.gui.appendChild(style);

        // Update crosshair visibility
        this.enhancedCrosshair.style.display = this.crosshairOn ? 'block' : 'none';
    }

    toggleGUI() {
        this.guiVisible = !this.guiVisible;
        this.gui.style.display = this.guiVisible ? 'block' : 'none';
        this.miniIndicator.style.display = this.guiVisible ? 'none' : 'block';

        this.showNotification(
            `UI ${this.guiVisible ? "Shown" : "Hidden"}`,
            1500
        );
    }

    // ========================
    // Input Handling
    // ========================

    setupEventListeners() {
        document.addEventListener('keydown', this.handleKeyDown.bind(this));
        document.addEventListener('keyup', this.handleKeyUp.bind(this));

        // FPS counter
        setInterval(() => {
            this.fps = Math.round(this.frameCount / 0.5);
            this.frameCount = 0;
            this.updateGUIDisplay();
        }, 500);
    }

    handleKeyDown(e) {
        const now = performance.now();
        const debounceDelay = this.ultraLowDelay ? 2 : 5;

        if (now - this.lastInputTime < debounceDelay) return;
        this.lastInputTime = now;

        // UI toggle
        if (e.key === 'End') {
            this.toggleGUI();
            e.preventDefault();
            return;
        }

        // Macro key configuration
        if (this.waitingForEditBind) {
            this.editBindKey = e.key.toLowerCase();
            this.configureMacro();
            e.preventDefault();
            return;
        }

        if (this.waitingForSelectEditBind) {
            this.selectEditBindKey = e.key.toLowerCase();
            this.configureMacro();
            e.preventDefault();
            return;
        }

        // Macro activation
        if (e.key.toLowerCase() === 'g' && this.macroEnabled && this.editBindKey && this.selectEditBindKey) {
            this.macroActive = true;
            this.executeMacro();
            e.preventDefault();
            return;
        }

        e.preventDefault();

        switch (e.key.toLowerCase()) {
            case 'w': this.moveY = -1; break;
            case 's': this.moveY = 1; break;
            case 'a': this.moveX = -1; break;
            case 'd': this.moveX = 1; break;

            case 'shift':
                this.virtualController.buttons[10].pressed = true;
                this.virtualController.buttons[10].value = 1;
                break;

            case 't':
                this.virtualController.buttons[6].pressed = true;
                this.virtualController.buttons[6].value = 1;
                break;

            case 'arrowup': this.targetAimY = -1; break;
            case 'arrowdown': this.targetAimY = 1; break;
            case 'arrowleft': this.targetAimX = -1; break;
            case 'arrowright': this.targetAimX = 1; break;

            case ' ':
                this.virtualController.buttons[7].pressed = true;
                this.virtualController.buttons[7].value = 1;
                break;

            case 'v': this.toggleVolumeBoost(); break;

            case 'i':
                this.ultraLowDelay = !this.ultraLowDelay;
                this.setupKeepAlive();
                this.updateVideoStyle();
                this.showNotification(
                    `Ultra Low Delay ${this.ultraLowDelay ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'o':
                this.highBitrate = !this.highBitrate;
                this.updateVideoStyle();
                this.showNotification(
                    `High Bitrate ${this.highBitrate ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'p':
                this.zoomIn = !this.zoomIn;
                if (this.zoomIn) {
                    this.zoomOut = false;
                    this.zoomMore = false;
                }
                this.updateVideoStyle();
                this.showNotification(
                    `Zoom In ${this.zoomIn ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'l':
                this.zoomOut = !this.zoomOut;
                if (this.zoomOut) {
                    this.zoomIn = false;
                    this.zoomMore = false;
                }
                this.updateVideoStyle();
                this.showNotification(
                    `Zoom Out ${this.zoomOut ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case ';':
                this.zoomMore = !this.zoomMore;
                if (this.zoomMore) {
                    this.zoomIn = false;
                    this.zoomOut = false;
                }
                this.updateVideoStyle();
                this.showNotification(
                    `Zoom 2x ${this.zoomMore ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'k':
                this.crosshairOn = !this.crosshairOn;
                this.enhancedCrosshair.style.display = this.crosshairOn ? 'block' : 'none';
                this.showNotification(
                    `Crosshair ${this.crosshairOn ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'u':
                this.speedHack = !this.speedHack;
                document.querySelectorAll('video').forEach(v => {
                    v.playbackRate = this.speedHack ? 1.5 : 1;
                });
                this.showNotification(
                    `Speed Hack ${this.speedHack ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'j':
                this.aimAssistEnabled = !this.aimAssistEnabled;
                if (!this.aimAssistEnabled && this.controllerInitialized) {
                    const disconnectEvent = new Event('gamepaddisconnected');
                    Object.defineProperty(disconnectEvent, 'gamepad', {
                        value: this.virtualController
                    });
                    window.dispatchEvent(disconnectEvent);
                    this.controllerInitialized = false;
                }
                this.showNotification(
                    `Controller ${this.aimAssistEnabled ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'm':
                this.macroEnabled = !this.macroEnabled;
                if (this.macroEnabled) {
                    this.editBindKey = null;
                    this.selectEditBindKey = null;
                    this.configureMacro();
                } else {
                    this.waitingForEditBind = false;
                    this.waitingForSelectEditBind = false;
                }
                this.showNotification(
                    `Macro ${this.macroEnabled ? "ON" : "OFF"}`,
                    2000
                );
                break;

            case 'f1':
                this.togglePerformanceMode();
                break;
        }

        this.updateGUIDisplay();
        this.updateController();
    }

    handleKeyUp(e) {
        const now = performance.now();
        const debounceDelay = this.ultraLowDelay ? 2 : 5;

        if (now - this.lastInputTime < debounceDelay) return;
        this.lastInputTime = now;

        if (e.key.toLowerCase() === 'g' && this.macroActive) {
            this.macroActive = false;
        }

        e.preventDefault();

        switch (e.key.toLowerCase()) {
            case 'w': case 's': this.moveY = 0; break;
            case 'a': case 'd': this.moveX = 0; break;

            case 'shift':
                this.virtualController.buttons[10].pressed = false;
                this.virtualController.buttons[10].value = 0;
                break;

            case 't':
                this.virtualController.buttons[6].pressed = false;
                this.virtualController.buttons[6].value = 0;
                break;

            case 'arrowup': case 'arrowdown': this.targetAimY = 0; break;
            case 'arrowleft': case 'arrowright': this.targetAimX = 0; break;

            case ' ':
                this.virtualController.buttons[7].pressed = false;
                this.virtualController.buttons[7].value = 0;
                break;

            case 'v':
                // Volume boost is toggled on keydown only
                break;
        }

        this.updateController();
    }

    // ========================
    // Main Loop
    // ========================

    startUpdateLoop() {
        const update = (timestamp) => {
            this.frameCount++;

            const timeDelta = timestamp - this.lastUpdateTime;
            const updateInterval = this.ultraLowDelay ? 8 : 16; // 125Hz vs 60Hz

            if (timeDelta >= updateInterval) {
                this.lastUpdateTime = timestamp;
                this.updateController();
            }

            requestAnimationFrame(update);
        };

        requestAnimationFrame(update);
    }
}

// Initialize the enhanced controller
const controllerEnhancer = new GameControllerEnhancer();