Krunker Precision Enhancer

Advanced player visualization and targeting system for Krunker with predictive algorithms
换行
// ==UserScript==
// @name         Krunker Precision Enhancer
// @namespace    https://github.com/SolitarianScripts
// @version      1.4.3
// @description  Advanced player visualization and targeting system for Krunker with predictive algorithms
// @author       Solitarian
// @license      All Rights Reserved
// @match        *://krunker.io/*
// @match        *://browserfps.com/*
// @exclude      *://krunker.io/social*
// @exclude      *://krunker.io/editor*
// @icon         https://img.icons8.com/color/96/000000/target.png
// @run-at       document-start
// @require      https://cdn.jsdelivr.net/npm/[email protected]/build/three.min.js
// @grant        GM_setValue
// @grant        GM_getValue
// ==/UserScript==

(function() {
    'use strict';

    const visualizationPalette = [
        { name: "Crimson", value: "0.86, 0.08, 0.24", style: "color: #dc143c" },
        { name: "Amber", value: "1.0, 0.75, 0.0", style: "color: #ffbf00" },
        { name: "Emerald", value: "0.0, 0.79, 0.34", style: "color: #00c957" },
        { name: "Azure", value: "0.0, 0.5, 1.0", style: "color: #007fff" },
        { name: "Violet", value: "0.54, 0.17, 0.89", style: "color: #8a2be2" },
        { name: "Onyx", value: "0.0, 0.0, 0.0", style: "color: #000000" },
        { name: "Pearl", value: "0.94, 0.94, 0.94", style: "color: #f0f0f0" },
        { name: "Jade", value: "0.0, 0.66, 0.42", style: "color: #00a86b" }
    ];

    const defaultConfig = {
        targetingEnabled: true,
        visualizationEnabled: true,
        trajectoryLines: true,
        visualizationColor: "0.86, 0.08, 0.24",
        visualizationColorIndex: 0,
        verticalAdjustment: 7.5,
        targetingMode: 'crosshairProximity',
        predictionIntensity: 0.85,
        targetingPrecision: 95,
        smoothTargeting: false,
        smoothingFactor: 25,
        uiCollapsed: false,
        lastActivePanel: null
    };

    const config = GM_getValue('krunkerEnhancerConfig', defaultConfig);

    const keyBindings = {
        KeyB: 'targetingEnabled',
        KeyN: 'visualizationEnabled',
        KeyM: 'trajectoryLines',
        KeyC: 'cycleVisualizationColor',
        BracketLeft: 'decreaseVerticalAdjustment',
        BracketRight: 'increaseVerticalAdjustment',
        Digit2: 'toggleTargetingMode',
        Digit3: 'smoothTargeting',
        Backslash: 'toggleUI'
    };

    const featureDescriptions = {
        targetingEnabled: "Targeting System [B]",
        visualizationEnabled: "Visualization [N]",
        trajectoryLines: "Trajectory Lines [M]",
        targetingMode: "Targeting Mode [2]",
        predictionIntensity: "Prediction Strength",
        targetingPrecision: "Targeting Precision",
        smoothTargeting: "Smooth Targeting [3]",
        smoothingFactor: "Smoothing Factor",
        visualizationColor: "Color Scheme [C]",
        verticalAdjustment: "Vertical Adjustment"
    };

    let sceneContext;
    let initializationTimer = null;
    let rightMouseActive = false;
    let targetLockActive = false;
    let lockedTarget = null;
    let targetPositionHistory = {};
    let lastTargetingTime = 0;

    const ThreeDEngine = window.THREE;
    delete window.THREE;

    const systemUtils = {
        window: window,
        document: document,
        querySelector: document.querySelector,
        log: console.log,
        arrayProto: Array.prototype,
        arrayPush: Array.prototype.push,
        requestFrame: window.requestAnimationFrame,
        setTimeout: window.setTimeout
    };

    systemUtils.log('Initializing precision enhancement system...');

    const sceneDetector = function(object) {
        try {
            if (typeof object === 'object' &&
                typeof object.parent === 'object' &&
                object.parent.type === 'Scene' &&
                object.parent.name === 'Main') {
                systemUtils.log('Scene context acquired');
                sceneContext = object.parent;
                systemUtils.arrayProto.push = systemUtils.arrayPush;
            }
        } catch (error) {}
        return systemUtils.arrayPush.apply(this, arguments);
    };

    const vectorCache1 = new ThreeDEngine.Vector3();
    const vectorCache2 = new ThreeDEngine.Vector3();
    const tempTransform = new ThreeDEngine.Object3D();
    tempTransform.rotation.order = 'YXZ';

    const playerGeometry = new ThreeDEngine.EdgesGeometry(
        new ThreeDEngine.BoxGeometry(4.8, 14.8, 4.8).translate(0, 7.4, 0)
    );

    let visualizationMaterial = new ThreeDEngine.RawShaderMaterial({
        vertexShader: `
            attribute vec3 position;
            uniform mat4 projectionMatrix;
            uniform mat4 modelViewMatrix;
            void main() {
                gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
                gl_Position.z = 1.0;
            }`,
        fragmentShader: `
            void main() {
                gl_FragColor = vec4(${config.visualizationColor}, 1.0);
            }`
    });

    const trajectoryVisual = new ThreeDEngine.LineSegments(
        new ThreeDEngine.BufferGeometry(),
        visualizationMaterial
    );
    trajectoryVisual.frustumCulled = false;
    const trajectoryPositions = new ThreeDEngine.BufferAttribute(
        new Float32Array(100 * 2 * 3),
        3
    );
    trajectoryVisual.geometry.setAttribute('position', trajectoryPositions);

    function updateVisualizationColor() {
        config.visualizationColorIndex =
            (config.visualizationColorIndex + 1) % visualizationPalette.length;
        const newColor = visualizationPalette[config.visualizationColorIndex];
        config.visualizationColor = newColor.value;

        visualizationMaterial = new ThreeDEngine.RawShaderMaterial({
            vertexShader: `
                attribute vec3 position;
                uniform mat4 projectionMatrix;
                uniform mat4 modelViewMatrix;
                void main() {
                    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
                    gl_Position.z = 1.0;
                }`,
            fragmentShader: `
                void main() {
                    gl_FragColor = vec4(${config.visualizationColor}, 1.0);
                }`
        });

        trajectoryVisual.material = visualizationMaterial;

        if (sceneContext && sceneContext.children) {
            for (let i = 0; i < sceneContext.children.length; i++) {
                const entity = sceneContext.children[i];
                if (entity.visualizationBox) {
                    entity.visualizationBox.material = visualizationMaterial;
                }
            }
        }

        const colorDisplay = document.querySelector(
            '[data-config-key="visualizationColor"] .value-display'
        );
        if (colorDisplay) {
            colorDisplay.textContent = newColor.name;
            colorDisplay.style = newColor.style;
        }

        saveConfiguration();
    }

    function restoreDefaultConfiguration() {
        Object.assign(config, defaultConfig);
        saveConfiguration();
        updateInterfaceConfiguration();
    }

    function handlePointerDown(e) {
        if (e.button === 2) {
            rightMouseActive = true;
            targetLockActive = false;
            lockedTarget = null;
        }
    }

    function handlePointerUp(e) {
        if (e.button === 2) {
            rightMouseActive = false;
            targetLockActive = false;
            lockedTarget = null;
        }
    }

    function saveConfiguration() {
        GM_setValue('krunkerEnhancerConfig', config);
    }

    function toggleConfiguration(key) {
        config[key] = !config[key];
        const itemElement = document.querySelector(`[data-config-key="${key}"]`);
        if (itemElement) {
            const valueElement = itemElement.querySelector('.value-display');
            valueElement.textContent = config[key] ? 'ON' : 'OFF';
            valueElement.style.color = config[key] ? '#4CAF50' : '#F44336';
        }
        saveConfiguration();
    }

    function switchTargetingMode() {
        config.targetingMode = config.targetingMode === 'crosshairProximity'
            ? 'distanceProximity'
            : 'crosshairProximity';
        const modeElement = document.querySelector('[data-config-key="targetingMode"]');
        if (modeElement) {
            const valueElement = modeElement.querySelector('.value-display');
            valueElement.textContent = config.targetingMode === 'crosshairProximity'
                ? 'Crosshair'
                : 'Distance';
            valueElement.style.color = '#4CAF50';
        }
        saveConfiguration();
    }

    function toggleInterface() {
        config.uiCollapsed = !config.uiCollapsed;
        updateInterfaceVisibility();
        saveConfiguration();
    }

    function updateVerticalAdjustmentDisplay() {
        const adjustmentInput = document.querySelector('#verticalAdjustmentInput');
        const adjustmentSlider = document.querySelector('#verticalAdjustmentSlider');
        if (adjustmentInput && adjustmentSlider) {
            adjustmentInput.value = config.verticalAdjustment;
            adjustmentSlider.value = config.verticalAdjustment;
        }
    }

    function updateInterfaceConfiguration() {
        Object.keys(config).forEach(key => {
            const itemElement = document.querySelector(`[data-config-key="${key}"]`);
            if (itemElement) {
                const valueElement = itemElement.querySelector('.value-display');
                if (valueElement) {
                    if (key === 'targetingMode') {
                        valueElement.textContent = config[key] === 'crosshairProximity'
                            ? 'Crosshair'
                            : 'Distance';
                        valueElement.style.color = '#4CAF50';
                    } else if (key === 'visualizationColor') {
                        valueElement.textContent = visualizationPalette[config.visualizationColorIndex].name;
                        valueElement.style = visualizationPalette[config.visualizationColorIndex].style;
                    } else if (typeof config[key] === 'boolean') {
                        valueElement.textContent = config[key] ? 'ON' : 'OFF';
                        valueElement.style.color = config[key] ? '#4CAF50' : '#F44336';
                    }
                }
            }
        });

        const verticalAdjustmentInput = document.querySelector('#verticalAdjustmentInput');
        const verticalAdjustmentSlider = document.querySelector('#verticalAdjustmentSlider');
        if (verticalAdjustmentInput && verticalAdjustmentSlider) {
            verticalAdjustmentInput.value = config.verticalAdjustment;
            verticalAdjustmentSlider.value = config.verticalAdjustment;
        }

        const predictionInput = document.querySelector('#predictionInput');
        const predictionSlider = document.querySelector('#predictionSlider');
        if (predictionInput && predictionSlider) {
            predictionInput.value = Math.round(config.predictionIntensity * 100);
            predictionSlider.value = config.predictionIntensity;
        }

        const precisionInput = document.querySelector('#precisionInput');
        const precisionSlider = document.querySelector('#precisionSlider');
        if (precisionInput && precisionSlider) {
            precisionInput.value = config.targetingPrecision;
            precisionSlider.value = config.targetingPrecision;
        }

        const smoothingInput = document.querySelector('#smoothingInput');
        const smoothingSlider = document.querySelector('#smoothingSlider');
        if (smoothingInput && smoothingSlider) {
            smoothingInput.value = config.smoothingFactor;
            smoothingSlider.value = config.smoothingFactor;
        }

        const interfaceElement = document.querySelector('.enhancer-interface');
        if (interfaceElement) {
            if (config.uiCollapsed) {
                interfaceElement.classList.remove('expanded');
            } else {
                interfaceElement.classList.add('expanded');
            }
        }

        if (config.lastActivePanel) {
            const panelElement = document.querySelector(
                `.panel-header:contains("${config.lastActivePanel}")`
            );
            if (panelElement) {
                panelElement.parentElement.classList.add('active');
            }
        }
    }

    function updateInterfaceVisibility() {
        const interfaceElement = document.querySelector('.enhancer-interface');
        if (interfaceElement) {
            if (config.uiCollapsed) {
                interfaceElement.classList.remove('expanded');
                interfaceElement.querySelector('.interface-status').textContent = '';
            } else {
                interfaceElement.classList.add('expanded');
                interfaceElement.querySelector('.interface-status').textContent = '';
            }
        }
    }

    function initializeInterface() {
        const interfaceContainer = document.createElement('div');
        interfaceContainer.innerHTML = `
            <style>
                .enhancer-interface {
                    position: fixed;
                    right: 10px;
                    top: 100px;
                    z-index: 999;
                    display: flex;
                    flex-direction: column;
                    font-family: 'Courier New', monospace;
                    font-size: 13px;
                    color: #e0e0e0;
                    width: 260px;
                    user-select: none;
                    border: 1px solid #333;
                    background: rgba(20, 20, 20, 0.9);
                    box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
                }

                .interface-header {
                    padding: 6px 10px;
                    background: #111;
                    cursor: move;
                    display: flex;
                    justify-content: space-between;
                    align-items: center;
                    border-bottom: 1px solid #333;
                }

                .interface-title {
                    font-size: 14px;
                    font-weight: bold;
                    color: #4CAF50;
                }

                .interface-status {
                    font-size: 12px;
                    color: #888;
                }

                .interface-content {
                    display: none;
                    flex-direction: column;
                }

                .enhancer-interface.expanded .interface-content {
                    display: flex;
                }

                .panel {
                    margin: 5px;
                    border: 1px solid #333;
                    background: rgba(30, 30, 30, 0.7);
                }

                .panel-header {
                    padding: 6px 10px;
                    background: #222;
                    cursor: pointer;
                    display: flex;
                    justify-content: space-between;
                    align-items: center;
                }

                .panel-header:hover {
                    background: #2a2a2a;
                }

                .panel-title {
                    font-weight: bold;
                    color: #4CAF50;
                }

                .panel-arrow {
                    transition: transform 0.2s;
                    color: #888;
                }

                .panel.active .panel-arrow {
                    transform: rotate(90deg);
                }

                .panel-content {
                    display: none;
                    flex-direction: column;
                }

                .panel.active .panel-content {
                    display: flex;
                }

                .control-item {
                    padding: 6px 10px;
                    display: flex;
                    flex-direction: column;
                    background: rgba(40, 40, 40, 0.7);
                    border-bottom: 1px solid #2a2a2a;
                }

                .control-item:last-child {
                    border-bottom: none;
                }

                .control-label {
                    display: flex;
                    justify-content: space-between;
                    align-items: center;
                    margin-bottom: 5px;
                }

                .control-name {
                    font-weight: bold;
                }

                .value-display {
                    font-size: 12px;
                    font-weight: bold;
                }

                .control-inputs {
                    display: flex;
                    flex-direction: column;
                    gap: 5px;
                }

                .slider-container {
                    display: flex;
                    align-items: center;
                    gap: 8px;
                }

                .slider-container input[type="range"] {
                    flex-grow: 1;
                    -webkit-appearance: none;
                    height: 4px;
                    background: #444;
                    outline: none;
                }

                .slider-container input[type="range"]::-webkit-slider-thumb {
                    -webkit-appearance: none;
                    appearance: none;
                    width: 12px;
                    height: 12px;
                    background: #4CAF50;
                    cursor: pointer;
                    border-radius: 50%;
                }

                .slider-container input[type="number"] {
                    width: 50px;
                    text-align: center;
                    background: #333;
                    border: 1px solid #444;
                    color: #fff;
                    padding: 2px;
                    font-size: 12px;
                }

                .action-button {
                    padding: 6px 10px;
                    background: #333;
                    text-align: center;
                    cursor: pointer;
                    border: 1px solid #444;
                    margin: 5px;
                    color: #008000;
                }

                .action-button:hover {
                    background: #3a3a3a;
                }
            </style>
            <div class="enhancer-interface ${config.uiCollapsed ? '' : 'expanded'}">
                <div class="interface-header">
                    <span class="interface-title">Precision Enhancer</span>
                    <span class="interface-status">[${config.uiCollapsed ? '+' : '-'}]</span>
                </div>
                <div class="interface-content">
                    <div class="panel ${config.lastActivePanel === 'Targeting System' ? 'active' : ''}">
                        <div class="panel-header">
                            <span class="panel-title">Targeting System</span>
                            <span class="panel-arrow">▶</span>
                        </div>
                        <div class="panel-content">
                            <div class="control-item" data-config-key="targetingEnabled">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.targetingEnabled}</span>
                                    <span class="value-display" style="color: ${config.targetingEnabled ? '#4CAF50' : '#F44336'}">${config.targetingEnabled ? 'ON' : 'OFF'}</span>
                                </div>
                            </div>

                            <div class="control-item" data-config-key="targetingMode">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.targetingMode}</span>
                                    <span class="value-display" style="color: #4CAF50">${config.targetingMode === 'crosshairProximity' ? 'Crosshair' : 'Distance'}</span>
                                </div>
                            </div>

                            <div class="control-item" data-config-key="smoothTargeting">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.smoothTargeting}</span>
                                    <span class="value-display" style="color: ${config.smoothTargeting ? '#4CAF50' : '#F44336'}">${config.smoothTargeting ? 'ON' : 'OFF'}</span>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="panel ${config.lastActivePanel === 'Visualization' ? 'active' : ''}">
                        <div class="panel-header">
                            <span class="panel-title">Visualization</span>
                            <span class="panel-arrow">▶</span>
                        </div>
                        <div class="panel-content">
                            <div class="control-item" data-config-key="visualizationEnabled">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.visualizationEnabled}</span>
                                    <span class="value-display" style="color: ${config.visualizationEnabled ? '#4CAF50' : '#F44336'}">${config.visualizationEnabled ? 'ON' : 'OFF'}</span>
                                </div>
                            </div>

                            <div class="control-item" data-config-key="trajectoryLines">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.trajectoryLines}</span>
                                    <span class="value-display" style="color: ${config.trajectoryLines ? '#4CAF50' : '#F44336'}">${config.trajectoryLines ? 'ON' : 'OFF'}</span>
                                </div>
                            </div>

                            <div class="control-item" data-config-key="visualizationColor">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.visualizationColor}</span>
                                    <span class="value-display" style="${visualizationPalette[config.visualizationColorIndex].style}">${visualizationPalette[config.visualizationColorIndex].name}</span>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="panel ${config.lastActivePanel === 'Configuration' ? 'active' : ''}">
                        <div class="panel-header">
                            <span class="panel-title">Configuration</span>
                            <span class="panel-arrow">▶</span>
                        </div>
                        <div class="panel-content">
                            <div class="control-item">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.predictionIntensity}</span>
                                </div>
                                <div class="control-inputs">
                                    <div class="slider-container">
                                        <input type="range" id="predictionSlider" min="0" max="1" step="0.01" value="${config.predictionIntensity}">
                                        <input type="number" id="predictionInput" value="${Math.round(config.predictionIntensity * 100)}" min="0" max="100" step="1">
                                    </div>
                                </div>
                            </div>

                            <div class="control-item">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.targetingPrecision}</span>
                                </div>
                                <div class="control-inputs">
                                    <div class="slider-container">
                                        <input type="range" id="precisionSlider" min="1" max="100" step="1" value="${config.targetingPrecision}">
                                        <input type="number" id="precisionInput" value="${config.targetingPrecision}" min="1" max="100" step="1">
                                    </div>
                                </div>
                            </div>

                            <div class="control-item">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.smoothingFactor}</span>
                                </div>
                                <div class="control-inputs">
                                    <div class="slider-container">
                                        <input type="range" id="smoothingSlider" min="1" max="100" step="1" value="${config.smoothingFactor}">
                                        <input type="number" id="smoothingInput" value="${config.smoothingFactor}" min="1" max="100" step="1">
                                    </div>
                                </div>
                            </div>

                            <div class="control-item">
                                <div class="control-label">
                                    <span class="control-name">${featureDescriptions.verticalAdjustment}</span>
                                </div>
                                <div class="control-inputs">
                                    <div class="slider-container">
                                        <input type="range" id="verticalAdjustmentSlider" min="-50" max="50" step="0.25" value="${config.verticalAdjustment}">
                                        <input type="number" id="verticalAdjustmentInput" value="${config.verticalAdjustment}" min="-50" max="50" step="0.25">
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="panel">
                        <div class="panel-header">
                            <span class="panel-title">System</span>
                            <span class="panel-arrow">▶</span>
                        </div>
                        <div class="panel-content">
                            <div class="action-button" id="resetSettings">
                                Reset All Settings
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        `;

        const panelHeaders = interfaceContainer.querySelectorAll('.panel-header');
        panelHeaders.forEach(header => {
            header.addEventListener('click', function() {
                const panel = this.parentElement;
                const wasActive = panel.classList.contains('active');

                document.querySelectorAll('.panel').forEach(p => {
                    p.classList.remove('active');
                });

                if (!wasActive) {
                    panel.classList.add('active');
                    config.lastActivePanel = this.querySelector('.panel-title').textContent;
                    saveConfiguration();
                } else {
                    config.lastActivePanel = null;
                    saveConfiguration();
                }
            });
        });

        const predictionSlider = interfaceContainer.querySelector('#predictionSlider');
        const predictionInput = interfaceContainer.querySelector('#predictionInput');
        if (predictionSlider && predictionInput) {
            predictionSlider.addEventListener('input', function() {
                config.predictionIntensity = parseFloat(this.value);
                predictionInput.value = Math.round(config.predictionIntensity * 100);
                saveConfiguration();
            });

            predictionInput.addEventListener('change', function() {
                const value = parseFloat(this.value);
                if (!isNaN(value)) {
                    const clampedValue = Math.max(0, Math.min(100, value));
                    config.predictionIntensity = clampedValue / 100;
                    predictionSlider.value = config.predictionIntensity;
                    this.value = clampedValue;
                    saveConfiguration();
                } else {
                    this.value = Math.round(config.predictionIntensity * 100);
                }
            });
        }

        const precisionSlider = interfaceContainer.querySelector('#precisionSlider');
        const precisionInput = interfaceContainer.querySelector('#precisionInput');
        if (precisionSlider && precisionInput) {
            precisionSlider.addEventListener('input', function() {
                config.targetingPrecision = parseInt(this.value);
                precisionInput.value = config.targetingPrecision;
                saveConfiguration();
            });

            precisionInput.addEventListener('change', function() {
                const value = parseInt(this.value);
                if (!isNaN(value)) {
                    const clampedValue = Math.max(1, Math.min(100, value));
                    config.targetingPrecision = clampedValue;
                    precisionSlider.value = clampedValue;
                    this.value = clampedValue;
                    saveConfiguration();
                } else {
                    this.value = config.targetingPrecision;
                }
            });
        }

        const smoothingSlider = interfaceContainer.querySelector('#smoothingSlider');
        const smoothingInput = interfaceContainer.querySelector('#smoothingInput');
        if (smoothingSlider && smoothingInput) {
            smoothingSlider.addEventListener('input', function() {
                config.smoothingFactor = parseInt(this.value);
                smoothingInput.value = config.smoothingFactor;
                saveConfiguration();
            });

            smoothingInput.addEventListener('change', function() {
                const value = parseInt(this.value);
                if (!isNaN(value)) {
                    const clampedValue = Math.max(1, Math.min(100, value));
                    config.smoothingFactor = clampedValue;
                    smoothingSlider.value = clampedValue;
                    this.value = clampedValue;
                    saveConfiguration();
                } else {
                    this.value = config.smoothingFactor;
                }
            });
        }

        const verticalAdjustmentSlider = interfaceContainer.querySelector('#verticalAdjustmentSlider');
        const verticalAdjustmentInput = interfaceContainer.querySelector('#verticalAdjustmentInput');
        if (verticalAdjustmentSlider && verticalAdjustmentInput) {
            verticalAdjustmentSlider.addEventListener('input', function() {
                config.verticalAdjustment = parseFloat(this.value);
                verticalAdjustmentInput.value = config.verticalAdjustment;
                saveConfiguration();
            });

            verticalAdjustmentInput.addEventListener('change', function() {
                const value = parseFloat(this.value);
                if (!isNaN(value)) {
                    const clampedValue = Math.max(-50, Math.min(50, value));
                    config.verticalAdjustment = clampedValue;
                    verticalAdjustmentSlider.value = clampedValue;
                    this.value = clampedValue;
                    saveConfiguration();
                } else {
                    this.value = config.verticalAdjustment;
                }
            });
        }

        const resetButton = interfaceContainer.querySelector('#resetSettings');
        if (resetButton) {
            resetButton.addEventListener('click', restoreDefaultConfiguration);
        }

        const interfaceHeader = interfaceContainer.querySelector('.interface-header');
        let isDragging = false;
        let startX, startY, initialX, initialY;

        interfaceHeader.addEventListener('mousedown', function(e) {
            if (e.button === 0) {
                isDragging = true;
                startX = e.clientX;
                startY = e.clientY;
                const rect = interfaceContainer.querySelector('.enhancer-interface').getBoundingClientRect();
                initialX = rect.left;
                initialY = rect.top;
                document.addEventListener('mousemove', onMouseMove);
                document.addEventListener('mouseup', onMouseUp);
            }
        });

        function onMouseMove(e) {
            if (!isDragging) return;

            const dx = e.clientX - startX;
            const dy = e.clientY - startY;

            let newX = initialX + dx;
            let newY = initialY + dy;

            const maxX = window.innerWidth - interfaceContainer.querySelector('.enhancer-interface').offsetWidth;
            const maxY = window.innerHeight - interfaceContainer.querySelector('.enhancer-interface').offsetHeight;
            newX = Math.max(0, Math.min(newX, maxX));
            newY = Math.max(0, Math.min(newY, maxY));

            interfaceContainer.querySelector('.enhancer-interface').style.left = `${newX}px`;
            interfaceContainer.querySelector('.enhancer-interface').style.top = `${newY}px`;
        }

        function onMouseUp() {
            if (isDragging) {
                isDragging = false;
                document.removeEventListener('mousemove', onMouseMove);
                document.removeEventListener('mouseup', onMouseUp);
            }
        }

        document.body.appendChild(interfaceContainer);
        updateInterfaceVisibility();
    }

    function systemLoop() {
        systemUtils.requestFrame.call(systemUtils.window, systemLoop);

        if (!sceneContext && !initializationTimer) {
            const loadingElement = systemUtils.querySelector.call(
                systemUtils.document, '#loadingBg'
            );
            if (loadingElement && loadingElement.style.display === 'none') {
                systemUtils.log('Starting initialization sequence');
                initializationTimer = systemUtils.setTimeout.call(systemUtils.window, () => {
                    systemUtils.log('System injection complete');
                    systemUtils.arrayProto.push = sceneDetector;
                }, 2000);
            }
        }

        if (sceneContext === undefined || !sceneContext.children) return;

        const playerEntities = [];
        let localPlayer;

        for (let i = 0; i < sceneContext.children.length; i++) {
            const entity = sceneContext.children[i];
            if (entity.type === 'Object3D') {
                try {
                    if (entity.children[0].children[0].type === 'PerspectiveCamera') {
                        localPlayer = entity;
                    } else {
                        playerEntities.push(entity);
                    }
                } catch (err) {}
            } else if (entity.material) {
                entity.material.wireframe = false;
            }
        }

        if (!localPlayer) {
            systemUtils.log('Local player not detected, reinitializing...');
            systemUtils.arrayProto.push = sceneDetector;
            return;
        }

        let positionCounter = 0;
        let currentTarget;
        let minimumDistance = Infinity;

        tempTransform.matrix.copy(localPlayer.matrix).invert();

        const currentPositions = {};
        for (let i = 0; i < playerEntities.length; i++) {
            const entity = playerEntities[i];
            currentPositions[entity.id] = entity.position.clone();
        }

        for (let i = 0; i < playerEntities.length; i++) {
            const entity = playerEntities[i];

            if (!entity.visualizationBox) {
                const visualizationBox = new ThreeDEngine.LineSegments(
                    playerGeometry,
                    visualizationMaterial
                );
                visualizationBox.frustumCulled = false;
                entity.add(visualizationBox);
                entity.visualizationBox = visualizationBox;
            }

            if (entity.position.x === localPlayer.position.x &&
                entity.position.z === localPlayer.position.z) {
                entity.visualizationBox.visible = false;
                if (trajectoryVisual.parent !== entity) {
                    entity.add(trajectoryVisual);
                }
                continue;
            }

            trajectoryPositions.setXYZ(positionCounter++, 0, 10, -5);
            vectorCache1.copy(entity.position);
            vectorCache1.y += 9;
            vectorCache1.applyMatrix4(tempTransform.matrix);
            trajectoryPositions.setXYZ(
                positionCounter++,
                vectorCache1.x,
                vectorCache1.y,
                vectorCache1.z
            );

            entity.visible = config.visualizationEnabled || entity.visible;
            entity.visualizationBox.visible = config.visualizationEnabled;

            let predictedPosition = entity.position.clone();
            if (targetPositionHistory[entity.id]) {
                const velocity = new ThreeDEngine.Vector3().subVectors(
                    currentPositions[entity.id],
                    targetPositionHistory[entity.id]
                );
                predictedPosition.add(velocity.multiplyScalar(config.predictionIntensity));
            }

            if (config.targetingMode === 'distanceProximity') {
                const dx = predictedPosition.x - localPlayer.position.x;
                const dy = predictedPosition.y - localPlayer.position.y;
                const dz = predictedPosition.z - localPlayer.position.z;
                const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);

                if (distance < minimumDistance && !targetLockActive) {
                    currentTarget = entity;
                    minimumDistance = distance;
                }
            } else if (config.targetingMode === 'crosshairProximity') {
                vectorCache1.copy(predictedPosition);
                vectorCache1.y += config.verticalAdjustment;

                const viewCamera = localPlayer.children[0].children[0];
                vectorCache1.project(viewCamera);

                const dx = vectorCache1.x;
                const dy = vectorCache1.y;
                const screenDistance = Math.sqrt(dx * dx + dy * dy);

                const playerForward = new ThreeDEngine.Vector3(0, 0, -1)
                    .applyQuaternion(localPlayer.quaternion);
                const toTarget = new ThreeDEngine.Vector3()
                    .subVectors(predictedPosition, localPlayer.position)
                    .normalize();
                const angle = Math.acos(playerForward.dot(toTarget)) * (180 / Math.PI);

                if (screenDistance < minimumDistance &&
                    !targetLockActive &&
                    angle < 90) {
                    currentTarget = entity;
                    minimumDistance = screenDistance;
                }
            }
        }

        targetPositionHistory = currentPositions;

        trajectoryPositions.needsUpdate = true;
        trajectoryVisual.geometry.setDrawRange(0, positionCounter);
        trajectoryVisual.visible = config.trajectoryLines;

        if (!rightMouseActive || !config.targetingEnabled) return;

        if (!targetLockActive) {
            lockedTarget = currentTarget;
            targetLockActive = true;
        }

        if (lockedTarget && !sceneContext.children.includes(lockedTarget)) {
            targetLockActive = false;
            lockedTarget = null;
            return;
        }

        if (lockedTarget === undefined) return;

        const currentTime = performance.now();
        const timeDelta = Math.min(50, currentTime - lastTargetingTime) / 1000;
        lastTargetingTime = currentTime;

        if (lockedTarget.children[0] &&
            lockedTarget.children[0].children[0] &&
            lockedTarget.children[0].children[0].type === 'PerspectiveCamera') {
            const headPosition = new ThreeDEngine.Vector3();
            lockedTarget.children[0].children[0].getWorldPosition(headPosition);

            if (targetPositionHistory[lockedTarget.id]) {
                const velocity = new ThreeDEngine.Vector3().subVectors(
                    currentPositions[lockedTarget.id],
                    targetPositionHistory[lockedTarget.id]
                );
                headPosition.add(velocity.multiplyScalar(config.predictionIntensity));
            }

            const direction = new ThreeDEngine.Vector3()
                .subVectors(headPosition, localPlayer.position)
                .normalize();

            if (config.targetingPrecision < 100) {
                const accuracyFactor = (100 - config.targetingPrecision) / 1000;
                direction.x += (Math.random() * 2 - 1) * accuracyFactor;
                direction.y += (Math.random() * 2 - 1) * accuracyFactor;
                direction.z += (Math.random() * 2 - 1) * accuracyFactor;
                direction.normalize();
            }

            const targetRotation = new ThreeDEngine.Quaternion();
            targetRotation.setFromUnitVectors(new ThreeDEngine.Vector3(0, 0, -1), direction);

            if (config.smoothTargeting) {
                const currentRotation = localPlayer.quaternion.clone();
                const t = Math.min(1, timeDelta * (config.smoothingFactor / 5));

                if (currentRotation.dot(targetRotation) < 0) {
                    targetRotation.negate();
                }

                localPlayer.quaternion.slerp(targetRotation, t);
            } else {
                localPlayer.quaternion.copy(targetRotation);
            }
        } else {
            let predictedPosition = lockedTarget.position.clone();
            if (targetPositionHistory[lockedTarget.id]) {
                const velocity = new ThreeDEngine.Vector3().subVectors(
                    currentPositions[lockedTarget.id],
                    targetPositionHistory[lockedTarget.id]
                );
                predictedPosition.add(velocity.multiplyScalar(config.predictionIntensity));
            }

            vectorCache1.copy(predictedPosition);
            vectorCache1.y += config.verticalAdjustment;
            tempTransform.position.copy(localPlayer.position);
            tempTransform.lookAt(vectorCache1);

            if (config.targetingPrecision < 100) {
                const accuracyFactor = (100 - config.targetingPrecision) / 1000;
                tempTransform.rotation.x += (Math.random() * 2 - 1) * accuracyFactor;
                tempTransform.rotation.y += (Math.random() * 2 - 1) * accuracyFactor;
            }

            if (config.smoothTargeting) {
                const t = Math.min(1, timeDelta * (config.smoothingFactor / 5));

                const currentXRot = localPlayer.children[0].rotation.x;
                const targetXRot = -tempTransform.rotation.x;
                localPlayer.children[0].rotation.x = currentXRot + (targetXRot - currentXRot) * t;

                const currentYRot = localPlayer.rotation.y;
                const targetYRot = tempTransform.rotation.y + Math.PI;

                let diff = targetYRot - currentYRot;
                if (diff > Math.PI) diff -= 2 * Math.PI;
                if (diff < -Math.PI) diff += 2 * Math.PI;

                localPlayer.rotation.y = currentYRot + diff * t;
            } else {
                localPlayer.children[0].rotation.x = -tempTransform.rotation.x;
                localPlayer.rotation.y = tempTransform.rotation.y + Math.PI;
            }
        }
    }

    // Initialize event listeners
    window.addEventListener('DOMContentLoaded', function() {
        initializeInterface();
    });

    // Start the system
    window.addEventListener('pointerdown', handlePointerDown);
    window.addEventListener('pointerup', handlePointerUp);
    window.addEventListener('pointercancel', handlePointerUp);
    window.addEventListener('mouseup', handlePointerUp);
    window.addEventListener('blur', function() {
        rightMouseActive = false;
        targetLockActive = false;
        lockedTarget = null;
    });
    window.addEventListener('contextmenu', function(e) {
        if (e.button === 2) e.preventDefault();
    });

    window.addEventListener('keydown', function(event) {
        if (systemUtils.document.activeElement &&
            systemUtils.document.activeElement.value !== undefined) return;

        if (event.code === 'BracketLeft') {
            config.verticalAdjustment = Math.max(-50, config.verticalAdjustment - 0.25);
            updateVerticalAdjustmentDisplay();
            saveConfiguration();
        } else if (event.code === 'BracketRight') {
            config.verticalAdjustment = Math.min(50, config.verticalAdjustment + 0.25);
            updateVerticalAdjustmentDisplay();
            saveConfiguration();
        }
    });

    window.addEventListener('keyup', function(event) {
        if (systemUtils.document.activeElement &&
            systemUtils.document.activeElement.value !== undefined) return;

        if (keyBindings[event.code]) {
            if (event.code === 'Digit2') {
                switchTargetingMode();
            } else if (event.code === 'Backslash') {
                toggleInterface();
            } else if (event.code === 'KeyC') {
                updateVisualizationColor();
            } else if (event.code === 'Digit3') {
                toggleConfiguration('smoothTargeting');
            } else {
                toggleConfiguration(keyBindings[event.code]);
            }
        }
    });

    // Start the main loop
    systemLoop();
})();