MineGun

FAST SHOOTING

이 스크립트를 설치하려면 Tampermonkey, Greasemonkey 또는 Violentmonkey와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 Tampermonkey와 같은 확장 프로그램을 설치해야 합니다.

이 스크립트를 설치하려면 Tampermonkey 또는 Violentmonkey와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 Tampermonkey 또는 Userscripts와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 Tampermonkey와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 유저 스크립트 관리자 확장 프로그램이 필요합니다.

(이미 유저 스크립트 관리자가 설치되어 있습니다. 설치를 진행합니다!)

Advertisement:

이 스타일을 설치하려면 Stylus와 같은 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 Stylus와 같은 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 Stylus와 같은 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 유저 스타일 관리자 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 유저 스타일 관리자 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 유저 스타일 관리자 확장 프로그램이 필요합니다.

(이미 유저 스타일 관리자가 설치되어 있습니다. 설치를 진행합니다!)

Advertisement:

// ==UserScript==
// @name         MineGun
// @namespace    http://tampermonkey.net/
// @version      7.7
// @description  FAST SHOOTING
// @author       Qwerty Matthew
// @match        https://minefun.io/*
// @match        https://*.minefun.io/*
// @match        http://minefun.io/*
// @match        http://*.minefun.io/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=minefun.io
// @grant        none
// @run-at
    document-idle
// @license      ISC
// ==/UserScript==

(function() {
    'use strict';

    // SILENT LOG FOR LOAD CONFIRMATION
    console.log('%c[MineGun] Script loading inside the shadows...', 'color: #ff00ff; font-size: 14px; font-weight: bold;');

    // Dummy status updater since the visual box is removed
    function updateStatus(status, color = '#00ff00') {
        console.log(`%c[Status Update] ${status}`, `color: ${color}; font-family: monospace;`);
    }

    // Indicators removed, updater functions made dummy to prevent console
    function updateHitAllIndicator(isActive) {}
    function updateInfectionWinIndicator(isActive) {}
    function showInfectionDebug(message, isError = false) {
        console.log(`%c[Debug Log] ${message}`, isError ?
 'color: #ff0000;' : 'color: #00ff00;');
    }
    function clearInfectionDebug() {}
    function hideInfectionDebug() {}

    // Keybinds menu toggler - simplified to console tracking only
    let menuVisible = false;
 let lastKPress = 0;
    window.addEventListener('keydown', (e) => {
        if (e.code === 'KeyK') {
            const now = Date.now();
            const timeSinceLastPress = now - lastKPress;

            if (timeSinceLastPress < 2000 && timeSinceLastPress > 100) {
                console.log('%c[MineGun] Cheat Status Check:', 'color: #00ffff;');

          console.log('Hacks active interval:', !!cheatInterval);
                console.log('Hit All loop active:', hitAllActive);
                lastKPress = 0;
            } else {
                lastKPress = now;
            }

   }
    });

    // Hook POKI SDK
    console.log('%c[MineGun] 🎯 Hooking POKI SDK...', 'color: #00ffff; font-size: 14px;');
 const pokiHandler = {
        get(target, prop) {
            if (prop === 'gameplayStart') {
                return function(...args) {
                    setTimeout(() => {
                        updateStatus('Press = or + to start', '#ffff00');

                    }, 1000);
 if (target[prop]) return target[prop].apply(target, args);
                };
            }
            if (prop === 'gameplayStop') {
                return function(...args) {
                    if (target[prop]) return target[prop].apply(target, args);
 };
            }
            return target[prop];
        }
    };
 Object.defineProperty(window, 'PokiSDK', {
        set(value) {
            if (value && typeof value === 'object') {
                this._pokiSDK = new Proxy(value, pokiHandler);
            } else {
                this._pokiSDK = value;
            }

   },
        get() { return this._pokiSDK; },
        configurable: true
    });
 // AUTO-ENABLE DEBUG MODE
    const originalCall = Function.prototype.call;
 Function.prototype.call = function(thisArg, ...args) {
        if (thisArg && typeof thisArg === 'object') {
            if (thisArg.player && thisArg.gameWorld && !window.hooked) {
                window.hooked = thisArg;
 updateStatus('Game detected! 🎮', '#00ff00');
            }
        }
        return originalCall.apply(this, [thisArg, ...args]);
 };

    const packetsOut = {
        TIME_STEP_INFO: 1, TIME_STEP: 2, DEATH: 3, REQUEST_RESPAWN: 4, PLAY_EMOTION: 5, PING: 7, PLACE_BLOCKS: 8, CHAT: 9, GET_PLAYERS: 10, CONVERT_MINEBUCKS: 11, FREE_AD: 12, HIT: 13, PASTE_CHUNK_BLOCKS: 22, FILL_AREA_WITH_BLOCKS: 23, PICKUP_DROP_ITEM: 24, SKIN_CHANGED: 25, USE_FOOD: 26, GOT_DAMAGE: 27, THROW_DYNAMITE: 28, THROW_PROJECTILE: 29, UPDATE_SIGN_TEXT: 30, SIGN_INPUT_REQUEST: 31, MODIFIERS_AMOUNT_TO_REQUEST: 500, GET_CHUNKS_MODIFIERS: 501, GET_ITEM_WITH_CREATE: 502, SHOOTER_CHANGE_WEAPON: 516, OPEN_LOOTBOX: 517, TRY_TO_USE_TNT: 520, USE_HAND_ITEM: 521, SET_CURRENT_ACTIVE_SLOT: 504, REPLACE_ITEMS_IN_BLOCK: 505, REPLACE_ITEMS: 506, MOVE_ITEMS_IN_BLOCK: 507, MOVE_ITEMS: 508, THROW_OUT_ITEM: 509, GET_BLOCK_VIA_WHEEL: 510, CHANGE_BLOCK_OPEN_STATE: 511, EXIT_FROM_STORAGE_BLOCK: 518, INST_DRAG_ITEM_TO_ARMOR: 519, OPEN_ITEM: 220, CRAFT: 221, START_TICKER: 222, ADD_PLAYER_TO_PRIVATE: 512, REMOVE_PLAYER_FROM_PRIVATE: 513,
 GET_PLAYER_PRIVATE_MEMBERS: 514, CREATE_PREFAB: 1101, DELETE_PREFAB: 1102, GET_PREFAB: 1103, GET_PREFABS: 1104, INSERT_PREFAB: 1105, ERASE_AREA: 1106, PUBLISH_PREFAB: 1107, HNS_ATTACK_BLOCK: 1200, HNS_PLAYER_LEFT_HIDED_STATE: 1201, CHOOSED_BLOCK: 1202, HNS_CHANGE_DOOR_STATE: 1203, HNS_GET_FREE_KIT: 1204, INFECTION_GET_WEAPON: 1300, INFECTION_SELECT_ZOMBIE: 1301, WAR_GET_WEAPON: 1400, SKY_WARS_SET_KIT: 1500, SKY_WARS_GET_FREE_KIT: 1501, ONE_BLOCK_PORTAL_REQUEST: 1550, ONE_BLOCK_GO_HOME: 1551
    };
 const packetsIn = {
        PLAYER_IN_CHUNK_RANGE: 1, PLAYER_OUT_OF_CHUNK_RANGE: 2, TIME_STEP: 3, UPD_SERVER_TIME: 4, PLAYERS_TIME_STEP_INFO: 5, PLAYER_DEAD: 6, PLAYER_RESPAWNED: 7, PLAYER_LEFT: 8, PLAY_PLAYER_EMOTION: 9, INIT_DATA: 10, CHANGE_PLAYER_SKIN: 11, PONG: 12, UPD_GAME_TIMER: 13, GAME_END: 14, ALERT: 16, CHAT_ALERT: 17, CONSOLE_LOG: 18, PLAYER_CURRENT_ITEM: 19, CHAT: 20, GET_PLAYERS: 21, UPDATE_SKIN: 22, UPDATE_PLAYER_SKIN: 23, SET_HEALTH: 24, SET_HUNGER: 25, PLAYER_FOOTSTEPS_HERABLE: 26, TNT_WAS_ACTIVATED: 27, TNT_EXPLODED: 28, UPD_TICKING_ENTITY_TRANSFORMS: 29, DYNAMITE_WAS_THROWN: 30, DYNAMITE_EXPLODED: 31, DEV_SPAWN_SMALL_CUBE_ON_XYZ: 32, PROJECTILE_WAS_THROWN: 33, PROJECTILE_COLLIDED: 34, SIGN_INPUT_REQUEST: 35, SIGN_CHANGE_TEXT: 36, CORRECT_POSITION: 37, INVENTORY: 501, UPDATE_ARMOR: 525, UPDATE_PLAYER_ARMOR: 526, INSIDE_ITEM_DATA: 527, CLOSE_ALL_MODALS: 528, UPDATE_DRAG_AND_OPENED_BLOCK: 529, BLOCK_STATE: 530, INIT_INFO: 502, UPDATE_NEAREST_CHUNKS:
 503, ALL_MODIFIERS_SENT: 504, CHUNK_MODIFIERS: 505, BLOCKS_TO_SET_BY_COORDS: 506, ERASE_BLOCKS: 508, SET_BLOCKS_BY_BLOCKS_OFFSETS: 509, PRIVATE_MEMBERS_DATA: 510, SHOOTER_SHOOT: 511, GOT_DAMAGE: 512, UPDATE_BALANCE: 513, UPD_STARTING_TIME: 522, YOU_DEAD: 523, PLAYER_GOT_DAMAGE: 524, SET_POS: 531, SET_ROT: 532, LOOTBOX_DATA: 514, SHOOTER_CHANGE_PLAYER_WEAPON: 515, ADD_DROP_ITEMS: 516, UPDATE_DROP_ITEMS: 517, DELETE_DROP_ITEMS: 518, DELETE_DROP_ITEM_BY_PICKUP: 519, FAILED_DROP_ITEM_PICKUP_ATTEMPT: 520, CREATIVE_PLOT_MARKER: 1100, PREFABS: 1101, PREFAB: 1102, HNS_PLAYER_HIDED: 1200, HNS_HUNTERS_AND_HIDERS: 1204, HNS_YOU_ARE_HIDER: 1205, HNS_PLAYER_LEFT_HIDED_STATE: 1207, HNS_LOCATE_HIDERS: 1208, HNS_PLAYER_WAS_ATTACKED: 1209, HNS_YOU_ARE_HUNTER: 1210, HNS_CHANGE_PLAYER_TO_HUNTER: 1211, HNS_UPD_HUNTERS_AND_HIDERS_AMOUNT: 1212, HNS_KILL_INFO: 1213, HNS_SHOW_BLOCKS_CHOICE_OPTIONS: 1214, HNS_CHANGE_PLAYER_BLOCK_ID: 1219, HNS_SET_LOCAL_PLAYER_BLOCK_ID: 1220, HNS_YOU_WAS_ATTACKED: 1221, HNS_HUNTERS_UNLOCKED: 1222, HNS_ADD_PHYSICS_IMPULSE: 1223, HNS_YOU_CANT_HIDE_HERE: 1225, WAR_PLAYER_DEATH: 1300, WAR_HURTED_PLAYER: 1301, WAR_YOU_KILLED_PLAYER: 1302, WAR_YOU_RESPAWNED: 1303, INFECTION_ZOMBIES_AND_SHOOTERS: 1350, INFECTION_YOU_TURN_TO_ZOMBIE: 1351, INFECTION_PLAYER_TURNED_TO_ZOMBIE: 1352, INFECTION_UPD_ZOMBIES_AND_SHOOTERS_AMOUNT: 1354, INFECTION_YOU_RESPAWNED:
 1356, INFECTION_HURTED_PLAYER: 1357, INFECTION_YOU_KILLED_PLAYER: 1358, INFECTION_DEATH_INFO: 1359, INFECTION_SHOOTER_WAS_ATTACKED: 1360, INFECTION_SET_WEAPON: 1361, INFECTION_SET_ZOMBIE_TYPE: 1362, INFECTION_UPDATE_HP: 1363, SKY_WARS_GAME_STARTED: 1400, SKY_WARS_NICKNAMES_DEPTH_TEST_FALSE: 1401, SKY_WARS_CHANGE_PLAYER_AVATAR: 1402, SKY_WARS_BOARD_PLACE: 1403, SKY_WARS_UPD_KILL_DEATH_BAR: 1404, ONE_BLOCK_PORTAL_REQUEST_REJECTED: 1450, ONE_BLOCK_DEATH: 1451, ONE_BLOCK_BLOCKS_DESTROYED: 1452, ONE_BLOCK_NEW_PHASE: 1453, ONE_BLOCK_LEADERBOARD: 1454
    };
 const _assign = Object.assign;
    const _defineProperty = Object.defineProperty;

    // Network Packet Interception
    let gameWebSocket = null;
 let gameActive = false;
    let packetLogging = false;

    const OriginalWebSocket = window.WebSocket;
 window.WebSocket = function(...args) {
        const ws = new OriginalWebSocket(...args);
        gameWebSocket = ws;
 ws.addEventListener('open', () => {
            updateStatus('Connected!', '#00ff00');
            gameActive = true;
        });
 return ws;
    };

    Object.defineProperty = function defineProperty() {
        const ret = _defineProperty.apply(this, arguments);
 if (arguments[0] && arguments[1]) {
            const propName = arguments[1];
 if (propName === 'player' || propName === 'gameWorld' || propName === 'server') {
                if (propName === 'player') {
                    window.hooked = ret;
 updateStatus('Ready! Press = to toggle.', '#ffff00');
                }
            }
        }
        return ret;
 };

    try {
        Object.defineProperty(Object.prototype, 'player', {
            get() { return this.__player; },
            set(v) {
                this.__player = v;
                if (v && v.gameWorld) {
                    window.hooked
 = this;
                    updateStatus('Game hooked! ✅', '#00ff00');
                }
            }
        });
 } catch (e) {}

    let findInterval = setInterval(() => {
        if (!window.hooked) {
            for (let key in window) {
                try {
                    if (window[key] && typeof window[key] === 'object' && window[key].player && window[key].gameWorld) {

             window.hooked = window[key];
                        clearInterval(findInterval);
                        break;
                    }
                } catch
                (e) {}
            }
        } else {
            clearInterval(findInterval);
        }
    }, 500);
 let cheatInterval;
    function cheatingIsFun() {
        if (cheatInterval) {
            clearInterval(cheatInterval);
 cheatInterval = false;
            updateStatus('Cheats OFF', '#ff0000');
            return;
        }

        updateStatus('ACTIVE! 🔥', '#00ff00');
 cheatInterval = setInterval(() => {
            // ESP
            try {
                window.hooked.gameWorld.server.players.forEach((plr) => {
                    plr.playerMaterial.depthTest = false;
                    if (plr.isHided) plr.model.visible = true;

               });
            } catch {}

            // No Fog
            try {
                if (window?.hooked?.gameWorld?.threeScene?.scene?.fog) {
                    _assign(window.hooked.gameWorld.threeScene.scene.fog, { near: 9999, far: 10000 });

             }
            } catch {}

            // Slipperiness Active
            try {
                _defineProperty(window.hooked.player.velocity, 'slipperiness', {
                    get() { return 1; },

                 set(v) {}
                });
            } catch {}

            // WEAPONS CONFIG (CRUCIAL RAPID FIRE HERE)
            try {
                const weaponMod = {

                   isAuto: true,
                    firerateMs: 15,          // ⚡ Lightning speed fire rate
                    lastShootFirerateMs: 15,
                    timeToScopeSec: 0.01,

                  reloadTimeMs: 1,
                    currAmmo: 30,
                    distance: 9999,
                    recoilDecayRatio: 999,

  recoilMax: 0.000001,
                    maxCrouchSpread: 0.000001,
                    maxStandSpread: 0.000001,
                    maxJumpInaccuracy: 0.000001,
                    maxMoveInaccuracy: 0.000001,

       knifeLongAttackDelayMs: 10,
                    knifeLongAttackFirerateMs: 15,
                    recoilAttackX: 0.0001,
                    recoilAttackY: 0.0001,
                    secondAttackDistance: 9999,

            swapTimeMs: 1
                };
 window.hooked.gameWorld.systemsManager.activeSystems.forEach((system) => {
                    if (system?.far) system.far = 9999;
                    if (system?.playerShooter?.currPlayerWeapon) {
                        _assign(system.playerShooter.currPlayerWeapon, weaponMod);
                    }

                     if (system?.playerShooter?.currPlayerWeaponSpec) {
                        _assign(system.playerShooter.currPlayerWeaponSpec, weaponMod);
                    }
                    if (system?.playerShooter?.currPlayerWeaponSpec?.bulletsQueue) {

       _assign(system.playerShooter.currPlayerWeaponSpec.bulletsQueue, { queueStepMs: 10 });
                    }
                    if (system?.playerShooter) {
                        _defineProperty(system, 'cooldownRemainderMs', {

       get() { return 10; },
                            set(v) {}
                        });
                        _defineProperty(system, 'shootPressedDelayer', {

                  get() { return 1;
 },
                            set(v) {}
                        });
 }
                });
 } catch {}

            // Hit Amplification
            try {
                if (typeof window.hooked.gameWorld.server.msgsToSend?._push !== 'function') {
                    window.hooked.gameWorld.server.msgsToSend._push = window.hooked.gameWorld.server.msgsToSend.push;
 window.hooked.gameWorld.server.msgsToSend.push = function () {
                        if (arguments[0] === packetsOut.HIT && Array.isArray(arguments[1])) {
                            for (let i = 0; i < 15; i++) this._push.apply(this, arguments);
 }
                        if (arguments[0] === packetsOut.HNS_ATTACK_BLOCK && Array.isArray(arguments[1])) {
                            for (let i = 0; i < 5; i++) this._push.apply(this, arguments);
 }
                        return this._push.apply(this, arguments);
 }
                }
            } catch {}

            // Instant Blocks
            try {
                let system = window.hooked.gameWorld.systemsManager.activeSystems.find(x => x?.infinityBlocks !== undefined);
 if (system) _defineProperty(system, 'instantBlockBreaking', {
                    get() { return true },
                    set(v) {}
                });
 } catch {}
        }, 100);
 }

    /* Teleportation Logic */
    function tp(x = 0, y = 0, z = 0, relative = true, sendToServer = true) {
        try {
            let position = window.hooked.player.position;
 let velocity = window.hooked.player.velocity.velVec3;
            if (relative) {
                position.x += x;
 position.y += y; position.z += z;
            } else {
                _assign(position, { x, y, z });
 }
            window.hooked.player.physicsPosComp.copyPos(position);
 if (sendToServer && window.hooked.gameWorld.server) {
                window.hooked.gameWorld.server.sendData(packetsOut.TIME_STEP, [
                    position.x, position.y, position.z,
                    velocity.x || 0, velocity.y || 0, velocity.z || 0,
                    window.hooked.gameWorld.time.localServerTimeMs

        ]);
            }
        } catch {}
    }

    /* Teleport to Selected Block */
    function tpToSelectedBlock() {
        try {
            let outlineSystem = window.hooked.gameWorld.systemsManager.activeSystems.find(x => x.currBlockPos);
 if (!outlineSystem) return;
            outlineSystem.intersectAndShow(true, 500);
            if (!outlineSystem.currBlockPos) return;
            let { x, y, z } = outlineSystem.currBlockPos;
 tz(x, y + 1, z, false);
        } catch {}
    }

    /* Silent Hit All Loop */
    function hitAll() {
        try {
            const mySessionId = window.hooked?.player?.sessionId;
 window.hooked.gameWorld.server.players.forEach(plr => {
                if (plr.sessionId === mySessionId) return;
                if (!plr.model || !plr.model.position) return;
                const { x, y, z } = plr.model.position;

                let hitSent = false;

 if (plr.hasOwnProperty('isBlock') && !plr.isHunter) {
                    window.hooked.gameWorld.server.sendData(packetsOut.HNS_ATTACK_BLOCK, [x, y + 0.1, z, 0.00000001, -0.9999999, 0.00000001, window.hooked.gameWorld.time.localServerTimeMs, plr.sessionId]);
                    hitSent = true;
                }
                else if (plr.hasOwnProperty('isZombie') && !plr.isZombie) {

               window.hooked.gameWorld.server.sendData(packetsOut.HIT, [window.hooked.gameWorld.time.localServerTimeMs, x, y + 0.1, z, 0.00000001, -0.9999999, 0.00000001, 2, plr.sessionId]);
                    hitSent = true;
                }
                else if (!hitSent) {

     window.hooked.gameWorld.server.sendData(packetsOut.HIT, [window.hooked.gameWorld.time.localServerTimeMs, x, y + 0.1, z, 0.00000001, -0.9999999, 0.00000001, 2, plr.sessionId]);
 }
            });
 } catch (e) {}
    }

    function removeFloor() {
        try {
            window.hooked.gameWorld.server.players.forEach(plr => {
                if (!plr.isAlive) return;
                let { x, y, z } = plr.model.position;
                x = Math.round(x); y = Math.round(y
 - 1); z = Math.round(z);
                for(let dx=-1; dx<=1; dx++) {
                    for(let dz=-1; dz<=1; dz++) {
                        window.hooked.gameWorld.server.sendData(packetsOut.PLACE_BLOCKS, [+(x+dx).toFixed(3), +y.toFixed(3), +(z+dz).toFixed(3), 1, `${x+dx},${y},${z+dz}`, 0]);
                    }

               }
            });
 } catch {}
    }

    function infectionWin() {
        try {
            if (!window.hooked?.gameWorld?.server?.players) return;
 const playersData = window.hooked.gameWorld.server.players;
            const mySessionId = window.hooked?.player?.sessionId;
            const humans = [];
 playersData.forEach(plr => {
                if (plr && plr.hasOwnProperty('isZombie') && !plr.isZombie && plr.sessionId !== mySessionId) {
                    humans.push(plr);
                }
            });
 if (humans.length === 0) return;

            const originalPos = { x: window.hooked.player.position.x, y: window.hooked.player.position.y, z: window.hooked.player.position.z };
            let currentIndex = 0;
 const killNextHuman = () => {
                if (currentIndex >= humans.length) {
                    tp(originalPos.x, originalPos.y, originalPos.z, false);
 return;
                }
                const human = humans[currentIndex];
 if (!human?.model?.position) { currentIndex++; killNextHuman(); return; }
                const { x, y, z } = human.model.position;
 tp(x, y + 1, z, false, true);
                setTimeout(() => {
                    tp(x, y + 1, z, false, true);
                    setTimeout(() => {
                        tp(x, y + 1, z, false, true);

            setTimeout(() => {
                            let hitCount = 0;
                            const rapidHitInterval = setInterval(() => {

          if (hitCount >= 8) {
                                    clearInterval(rapidHitInterval);
                                    currentIndex++;

                      setTimeout(killNextHuman, 800);
                                    return;
                                }

                       try {
                                    if (hitCount % 3 === 0) tp(x, y + 1, z, false, true);

        window.hooked.gameWorld.server.sendData(packetsOut.HIT, [window.hooked.gameWorld.time.localServerTimeMs, x, y + 0.1, z, 0.00000001, -0.9999999, 0.00000001, 2, human.sessionId]);
                                    hitCount++;
 } catch (e) {}
                            }, 40);
 }, 300);
                    }, 200);
                }, 200);
            };
            killNextHuman();
        } catch (e) {}
    }

    function allowBinds() {
        return (document?.pointerLockElement && document?.activeElement?.tagName !== 'INPUT');
 }

    let hitAllActive = false;
    let hitAllInterval = null;
 function toggleHitAll() {
        hitAllActive = !hitAllActive;
 if (hitAllActive) {
            hitAll();
 hitAllInterval = setInterval(() => { hitAll(); }, 450);
        } else {
            if (hitAllInterval) { clearInterval(hitAllInterval);
 hitAllInterval = null; }
        }
    }

    const pressedKeys = { allowBackquote: true, allowPeriod: true, allowComma: true, allowKeyH: true, allowEqual: true };
 function unlockKey(code) { pressedKeys[`allow${code}`] = true; }

    window.addEventListener('keydown', (event) => { pressedKeys[event.code] = true; });
 window.addEventListener('keyup', (event) => { pressedKeys[event.code] = false; });

    function keybindsLoop() {
        if (allowBinds()) {
            // Spacebar Fly logic fully removed for pure vanilla jumping
            if (pressedKeys['Backquote'] && pressedKeys.allowBackquote) {
                if (window?.hooked?.player?.velocity?.velVec3) {
                    pressedKeys.allowBackquote = false;
 setTimeout(unlockKey.bind(this, ['Backquote']), 400);
                    tpToSelectedBlock();
                }
            }
            if (pressedKeys['Period'] && pressedKeys.allowPeriod) {
                if (window?.hooked?.gameWorld) {
                    pressedKeys.allowPeriod = false;
 setTimeout(unlockKey.bind(this, ['Period']), 500);
                    toggleHitAll();
                }
            }
            if (pressedKeys['Comma'] && pressedKeys.allowComma) {
                if (window?.hooked?.gameWorld?.server?.sendData) {
                    pressedKeys.allowComma = false;
 setTimeout(unlockKey.bind(this, ['Comma']), 200);
                    removeFloor();
                }
            }
            if (pressedKeys['KeyH'] && pressedKeys.allowKeyH) {
                // KeyH has been cleanly deactivated here
            }
            if ((pressedKeys['Equal'] || pressedKeys['NumpadAdd']) && pressedKeys.allowEqual) {
                pressedKeys.allowEqual = false;
 setTimeout(unlockKey.bind(this, ['Equal']), 1000);
                cheatingIsFun();
            }
        }
        requestAnimationFrame(keybindsLoop);
 }

    // Initialize the hidden loop
    setTimeout(() => { keybindsLoop(); }, 8000);
 // Auto-activate after 2 seconds to match preferences seamlessly
    setTimeout(() => {
        if (!cheatInterval) cheatingIsFun();
    }, 2000);
 })();