Gulper.io JHack

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

您需要先安裝使用者腳本管理器擴展,如 TampermonkeyGreasemonkeyViolentmonkey 之後才能安裝該腳本。

You will need to install an extension such as Tampermonkey to install this script.

您需要先安裝使用者腳本管理器擴充功能,如 TampermonkeyViolentmonkey 後才能安裝該腳本。

您需要先安裝使用者腳本管理器擴充功能,如 TampermonkeyUserscripts 後才能安裝該腳本。

你需要先安裝一款使用者腳本管理器擴展,比如 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);
    };

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