Gulper.io JHack

Zoom Hack, Auto Respawn, Disable AdBlock Detection, Auto Run and Server Selector

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴Greasemonkey 油猴子Violentmonkey 暴力猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴Violentmonkey 暴力猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴Userscripts ,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展,例如 Tampermonkey 篡改猴,才能安装此脚本。

您需要先安装一款用户脚本管理器扩展后才能安装此脚本。

(我已经安装了用户脚本管理器,让我安装!)

您需要先安装一款用户样式管理器扩展,比如 Stylus,才能安装此样式。

您需要先安装一款用户样式管理器扩展,比如 Stylus,才能安装此样式。

您需要先安装一款用户样式管理器扩展,比如 Stylus,才能安装此样式。

您需要先安装一款用户样式管理器扩展后才能安装此样式。

您需要先安装一款用户样式管理器扩展后才能安装此样式。

您需要先安装一款用户样式管理器扩展后才能安装此样式。

(我已经安装了用户样式管理器,让我安装!)

// ==UserScript==
// @name         Gulper.io JHack
// @namespace    http://tampermonkey.net/
// @version      0.13-alpha
// @description  Zoom Hack, Auto Respawn, Disable AdBlock Detection, Auto Run and Server Selector
// @author       You
// @match        https://gulper.io/
// @icon         https://www.google.com/s2/favicons?sz=64&domain=gulper.io
// @grant        none
// ==/UserScript==

(function() {
    'use strict';
    // for console injection
    const scriptUrl = 'https://raw.githubusercontent.com/cheat-cloud/gulper.io/refs/heads/main/modifiedEngiene.txt';

        fetch(scriptUrl)
            .then(response => {
                return response.text();
            })
            .then(code => {
                const scriptElement = document.createElement('script');
                scriptElement.textContent = code;
                document.head.appendChild(scriptElement);
            })
    // for tampermonkey
    window.addEventListener('load', function() {
        const scriptUrl = 'https://raw.githubusercontent.com/cheat-cloud/gulper.io/refs/heads/main/modifiedEngiene.txt';

        fetch(scriptUrl)
            .then(response => {
                if (!response.ok) throw new Error('Ошибка сети при загрузке скрипта');
                return response.text();
            })
            .then(code => {
                const scriptElement = document.createElement('script');
                scriptElement.textContent = code;
                document.head.appendChild(scriptElement);
            })
            .catch(error => {
            alert('Error while loading modified engiene'
    )});
        (function() {
    const menu = document.createElement('div');
    menu.id = 'custom-menu-overlay';

    const style = document.createElement('style');
    style.innerHTML = `
        #custom-menu-overlay {
            position: fixed;
            top: 50px;
            left: 50px;
            width: 350px;
            background: #0d0d0d;
            border: 1px solid #1a1a1a;
            border-radius: 4px;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            color: #e0e0e0;
            z-index: 10000;
            user-select: none;
            box-shadow: 0 10px 30px rgba(0,0,0,0.5);
        }
        .menu-header {
            padding: 12px 15px;
            border-bottom: 1px solid #1a1a1a;
            display: flex;
            align-items: center;
            cursor: move;
        }
        .menu-logo {
            color: #00ffa3;
            font-size: 18px;
            margin-right: 10px;
            font-weight: bold;
        }
        .menu-content {
            padding: 20px;
        }
        .section-title {
            color: #00ffa3;
            font-size: 12px;
            text-transform: uppercase;
            letter-spacing: 1px;
            margin-bottom: 15px;
            border-bottom: 1px solid #1a1a1a;
            padding-bottom: 5px;
        }
        .control-row {
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 12px;
            font-size: 13px;
            color: #b0b0b0;
        }
        .control-row:hover {
            color: #ffffff;
        }
        /* Custom checkbox */
        .checkbox-wrapper {
            width: 18px;
            height: 18px;
            background: #1a1a1a;
            border-radius: 2px;
            cursor: pointer;
            display: flex;
            align-items: center;
            justify-content: center;
            transition: 0.2s;
        }
        .checkbox-wrapper.active {
            color: #00ffa3;
        }
        .checkbox-wrapper.active::after {
            content: '✔';
            font-size: 12px;
        }
        /* Custom slider */
        .slider-input {
            -webkit-appearance: none;
            width: 120px;
            height: 4px;
            background: #1a1a1a;
            border-radius: 2px;
            outline: none;
        }
        .slider-input::-webkit-slider-thumb {
            -webkit-appearance: none;
            width: 12px;
            height: 12px;
            background: #00ffa3;
            border-radius: 50%;
            cursor: pointer;
        }
        .slider-input.disabled {
            opacity: 0.5;
            cursor: not-allowed;
        }
        .slider-input.disabled::-webkit-slider-thumb {
            cursor: not-allowed;
        }
        .value-display {
            margin-left: 10px;
            font-size: 12px;
            color: #00ffa3;
        }
        /* Server select styles */
        .server-select {
            width: 100%;
            background: #1a1a1a;
            border: 1px solid #2a2a2a;
            border-radius: 3px;
            padding: 6px 8px;
            color: #e0e0e0;
            font-size: 12px;
            cursor: pointer;
            margin-top: 5px;
        }
        .server-select option {
            background: #1a1a1a;
        }
        .server-row {
            margin-top: 10px;
        }
        .note-text {
            font-size: 10px;
            color: #666;
            margin-top: 5px;
            text-align: center;
        }
    `;
    document.head.appendChild(style);

    // Variables
    let zoomEnabled = false;
    let zoomInterval = null;
    let autoRespawnInterval = null;
    let autoRunActive = false;
    let autoRunLoopRunning = false;
    let currentZoom = 0.5;

    menu.innerHTML = `
        <div class="menu-header">
            <span class="menu-logo">∞</span>
            <span style="font-size: 13px; font-weight: 500;">Main Module</span>
        </div>
        <div class="menu-content">
            <div class="section-title">Settings</div>

            <div class="control-row">
                <span>Enable Zoom Hack (Edit in main menu)</span>
                <div class="checkbox-wrapper" id="zoomToggle"></div>
            </div>

            <div class="control-row">
                <span>Zoom</span>
                <div style="display: flex; align-items: center;">
                    <input type="range" class="slider-input" id="zoomSlider" min="0.1" max="3" step="0.01" value="0.5" disabled>
                    <span class="value-display" id="zoomValue">0.50</span>
                </div>
            </div>

            <div class="control-row">
                <span>Auto Respawn</span>
                <div class="checkbox-wrapper" id="respawnToggle"></div>
            </div>

            <div class="control-row">
                <span>Auto Run</span>
                <div class="checkbox-wrapper" id="autoRunToggle"></div>
            </div>

            <div class="control-row">
                <span>Disable Adblock Detect</span>
                <div class="checkbox-wrapper" id="adblockToggle"></div>
            </div>

            <div class="section-title" style="margin-top: 15px;">Server Selection</div>
            <div class="control-row server-row">
                <span>Connect Only To Selected Server</span>
                <div class="checkbox-wrapper" id="serverSelectorToggle"></div>
            </div>
            <div class="control-row" id="serverSelectRow" style="display: none;">
                <select id="serverSelect" class="server-select"></select>
            </div>
        </div>
    `;

    document.body.appendChild(menu);

    const zoomToggle = menu.querySelector('#zoomToggle');
    const zoomSlider = menu.querySelector('#zoomSlider');
    const zoomValue = menu.querySelector('#zoomValue');
    const respawnToggle = menu.querySelector('#respawnToggle');
    const autoRunToggle = menu.querySelector('#autoRunToggle');
    const adblockToggle = menu.querySelector('#adblockToggle');
    const serverSelectorToggle = menu.querySelector('#serverSelectorToggle');
    const serverSelectRow = menu.querySelector('#serverSelectRow');
    const serverSelect = menu.querySelector('#serverSelect');

    let serverFilterEnabled = false;

    function parseServerList(serversString) {
        if (!serversString) return [];
        const servers = serversString.split(',');
        return servers.map(server => {
            const parts = server.split('|');
            if (parts.length >= 4) {
                const hostParts = parts[0].split('.');
                let code = '';
                if (hostParts[0].length >= 3) {
                    code = hostParts[0].slice(-3);
                } else {
                    code = hostParts[0];
                }
                return {
                    fullString: server,
                    host: parts[0],
                    code: code,
                    regionCode: code.slice(0, 2)
                };
            }
            return null;
        }).filter(s => s !== null);
    }

    function getRegionDisplayName(regionCode) {
        switch(regionCode) {
            case 'eu': return 'Europe';
            case 'na': return 'North America';
            case 'as': return 'Australia';
            case 'au': return 'Australia v2';
            case 'sa': return 'South America';
            default: return regionCode.toUpperCase();
        }
    }

    function updateServerList() {
        if (typeof GAME_SERVERS !== 'undefined') {
            const servers = parseServerList(GAME_SERVERS);
            serverSelect.innerHTML = '';

            servers.forEach((server, index) => {
                const option = document.createElement('option');
                const regionName = getRegionDisplayName(server.regionCode);
                option.value = server.fullString;
                option.textContent = `${regionName} ${server.code}`;
                serverSelect.appendChild(option);
            });
        }
    }

    function applyServerFilter() {
        if (serverFilterEnabled && serverSelect.value) {
            if (typeof GAME_SERVERS !== 'undefined') {
                window.GAME_SERVERS = serverSelect.value;
            }
        }
    }

    function startServerMonitoring() {
        setInterval(() => {
            if (serverFilterEnabled) {
                updateServerList();
                if (serverSelect.options.length > 0 && !serverSelect.value) {
                    serverSelect.selectedIndex = 0;
                }
                applyServerFilter();
            } else {
                updateServerList();
            }
        }, 600000);
    }

    serverSelectorToggle.addEventListener('click', function() {
        this.classList.toggle('active');
        serverFilterEnabled = this.classList.contains('active');

        if (serverFilterEnabled) {
            serverSelectRow.style.display = 'flex';
            updateServerList();
            if (serverSelect.options.length > 0) {
                serverSelect.selectedIndex = 0;
                applyServerFilter();
            }
        } else {
            serverSelectRow.style.display = 'none';
            if (typeof GAME_SERVERS !== 'undefined' && window.originalGameServers) {
                window.GAME_SERVERS = window.originalGameServers;
            }
        }
    });

    serverSelect.addEventListener('change', function() {
        if (serverFilterEnabled) {
            applyServerFilter();
        }
    });

    if (typeof GAME_SERVERS !== 'undefined') {
        window.originalGameServers = GAME_SERVERS;
        updateServerList();
        startServerMonitoring();
    } else {
        const checkGameServers = setInterval(() => {
            if (typeof GAME_SERVERS !== 'undefined') {
                window.originalGameServers = GAME_SERVERS;
                updateServerList();
                startServerMonitoring();
                clearInterval(checkGameServers);
            }
        }, 1000);
    }

    function applyZoom(value) {
        if (zoomEnabled) {
           zoom = value
        }
    }

    zoomToggle.addEventListener('click', function() {
        this.classList.toggle('active');
        zoomEnabled = this.classList.contains('active');
        if (zoomEnabled) {
            zoomSlider.disabled = false;
            zoomSlider.classList.remove('disabled');
            applyZoom(currentZoom);
        } else {
            zoomSlider.disabled = true;
            zoomSlider.classList.add('disabled');
            applyZoom(0.5);
        }
    });

    zoomSlider.addEventListener('input', function(e) {
        currentZoom = parseFloat(e.target.value);
        zoomValue.textContent = currentZoom.toFixed(2);
        if (zoomEnabled) {
            applyZoom(currentZoom);
        }
    });

    let respawnEnabled = false;
    respawnToggle.addEventListener('click', function() {
        this.classList.toggle('active');
        respawnEnabled = this.classList.contains('active');
        if (respawnEnabled) {
            if (autoRespawnInterval) clearInterval(autoRespawnInterval);

            autoRespawnInterval = setInterval(() => {
                const restartBtn = document.getElementById('restart-btn');
                if (restartBtn && respawnEnabled) {
                    restartBtn.click();
                }
            }, 10);
        } else {

            if (autoRespawnInterval) {
                clearInterval(autoRespawnInterval);
                autoRespawnInterval = null;
            }
        }
    });

    // Auto Run функция
    async function startAutoRun() {
        if (autoRunLoopRunning) return;

        autoRunLoopRunning = true;

        const canvas = document.querySelector('main-canvas') || document.querySelector('canvas');

        if (!canvas) {
            autoRunLoopRunning = false;
            autoRunToggle.classList.remove('active');
            autoRunActive = false;
            return;
        }

        while (autoRunActive && autoRunLoopRunning) {
            canvas.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
            await new Promise(r => setTimeout(r, 2500));

            if (!autoRunActive) break;

            canvas.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
            await new Promise(r => setTimeout(r, 50));
        }

        autoRunLoopRunning = false;
    }

    function stopAutoRun() {
        autoRunActive = false;
        autoRunLoopRunning = false;
    }

    autoRunToggle.addEventListener('click', function() {
        this.classList.toggle('active');
        autoRunActive = this.classList.contains('active');

        if (autoRunActive) {
            startAutoRun();
        } else {
            stopAutoRun();
        }
    });

    let adblockEnabled = false;
    adblockToggle.addEventListener('click', function() {
        this.classList.toggle('active');
        adblockEnabled = this.classList.contains('active');

        if (adblockEnabled) {
            if (typeof window.ADS_BLOCKED !== 'undefined') {
                window.ADS_BLOCKED = false;
            }

            window.ADS_BLOCKED = false;

            if (typeof window.adblockDetected !== 'undefined') window.adblockDetected = false;
            if (typeof window.adBlockEnabled !== 'undefined') window.adBlockEnabled = false;

            if (typeof window.checkAdblock === 'function') {
                window.checkAdblock = function() { return false; };
            }

        } else {
        }
    });

    zoomToggle.classList.remove('active');
    zoomToggle.classList.add('active');
    zoomToggle.classList.remove('active');

    respawnToggle.classList.remove('active');
    autoRunToggle.classList.remove('active');
    adblockToggle.classList.remove('active');

    let isDragging = false;
    let offsetX, offsetY;

    menu.querySelector('.menu-header').addEventListener('mousedown', (e) => {
        isDragging = true;
        offsetX = e.clientX - menu.offsetLeft;
        offsetY = e.clientY - menu.offsetTop;
    });

    document.addEventListener('mousemove', (e) => {
        if (isDragging) {
            menu.style.left = (e.clientX - offsetX) + 'px';
            menu.style.top = (e.clientY - offsetY) + 'px';
        }
    });

    document.addEventListener('mouseup', () => {
        isDragging = false;
    });

    window.cleanupMenu = function() {
        if (autoRespawnInterval) clearInterval(autoRespawnInterval);
        if (zoomInterval) clearInterval(zoomInterval);
        stopAutoRun();
        if (menu && menu.parentNode) menu.parentNode.removeChild(menu);
        if (style && style.parentNode) style.parentNode.removeChild(style);
    };

})();
    });
})();