Shell Shockers aimbot script

// ==UserScript==
// @name         ShellShockers Aimbot and ESP
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       PacyTense
// @match        *://shellshock.io/*
// @run-at       document-start
// @grant        none
// @noframes
// ==/UserScript==




window.settings = {
    blueTeam: "#4254f5",
    redTeam: "#eb3326",
    orangeTeam: "#fca503",
    aimbotKey: "ShiftLeft",
    angleOrDistance: true,
    aimbotSmoothness: 2,
    maxAngle: 3,
    fov: 1.25,
}


window.aimbotToggled = false;

window.addEventListener('keydown', function(e){
    if(e.code == window.settings.aimbotKey){
        window.aimbotToggled = true;
    }

})

window.addEventListener('keyup', function(e){
    if(e.code == window.settings.aimbotKey){
        window.aimbotToggled = false;
    }

})

window.dist3d = (player1, player2)=>{return Math.sqrt((player1.x-player2.x)**2 + (player1.y-player2.y)**2 + (player1.z-player2.z)**2)};

window.angleDistance =(player1, player2)=>{


    let angle = window.getAngle(player1, player2);

    const angleDist = Math.sqrt((player1.yaw - angle.yaw)**2 + (player1.pitch - angle.pitch)**2);
    return angleDist*window.dist3d(player1, player2);

}


window.getNearestPlayer = function(us, enemies){

    let nearestPlayer = {distance: null, player: null} //we leave it empty to start

    enemies.forEach(them=>{

        if(them){ //sometimes a glitched player slips thorugh, so lets make sure they are valid before we do anything

            if(them.id != us.id){ //our own player is in here, so lets make sure to filter it out

                if(them.hp > 0 && them.playing && (!us.team || (us.team != them.team)) && window.visiblePlayers[them.id]){
                    //firstly lets make sure they arent dead hp > 0, then make sure they are playing and not spectating
                    //then lets check if our team is equal to their team
                    //one thing to note, in FFA both our teams are 0, so it would never run cause it would think we are on their team
                    //so what we do is if(us.team) will return false for team = 0 and true for team != 0
                    // so it is effectivly if our team is 0 (FFA) or our team isnt equal to their team```

                    let distance = 999;
                    if(window.settings.angleOrDistance){
                        distance = window.angleDistance(us,them) || 0;
                    }else{
                        distance = window.dist3d(us,them) || 0;
                    }
                    if(  !nearestPlayer.distance || distance < nearestPlayer.distance  ){
                        nearestPlayer.distance = distance;
                        nearestPlayer.player = them;
                    }
                }
            }
        }
    })
    if(nearestPlayer.player){
        return nearestPlayer;
    }
    return null;
}

window.calcAngle = function(us, them, dist){
    let delta = {x: them.x - us.x + 2*(them.dx * dist / us.weapon.subClass.velocity),
                 y: them.y-us.y - 0.072,
                 z: them.z - us.z + 2*(them.dz * dist / us.weapon.subClass.velocity)
                };

    delta = new BABYLON.Vector3(delta.x, delta.y, delta.z).normalize();
    const newYaw = Math.radRange(-Math.atan2(delta.z, delta.x) + Math.PI / 2)

    const newPitch = Math.clamp(-Math.asin(delta.y), -1.5, 1.5);



    us.pitch += ((newPitch || 0)-us.pitch)/window.settings.aimbotSmoothness;
    us.yaw += ((newYaw || 0)-us.yaw)/window.settings.aimbotSmoothness;


    return 0;
}

window.getAngle = function(us, them){
    let delta = {x: them.x - us.x ,
                 y: them.y-us.y - 0.072,
                 z: them.z - us.z,
                };

    delta = new BABYLON.Vector3(delta.x, delta.y, delta.z).normalize();
    const newYaw = Math.radRange(-Math.atan2(delta.z, delta.x) + Math.PI / 2)

    const newPitch = Math.clamp(-Math.asin(delta.y), -1.5, 1.5);


    return {pitch: newPitch || 0, yaw: newYaw || 0};
}



//aimbot function
window.otherPlayer;
window.myPlayer;

window.espColourSettings = function(that){
    if(that.player.team==1){
        that.bodyMesh.overlayColor = hexToRgb(window.settings.blueTeam);
    }else if(that.player.team==2){
        that.bodyMesh.overlayColor = hexToRgb(window.settings.redTeam);
    }else{
        that.bodyMesh.overlayColor = hexToRgb(window.settings.orangeTeam);
    }
    that.bodyMesh.setRenderingGroupId(1);
}

window.doAimbot = (ourPlayer,otherPlayers)=>{

    if(!window.aimbotToggled){return};
    if(!window.myPlayer){
        otherPlayers.forEach(player=>{
            if(player){
                if(player.ws){
                    window.myPlayer = player;
                }}
        })
    };
    //loop through other palyers
    let nearest = window.getNearestPlayer(ourPlayer, otherPlayers);
    if(nearest){
        //console.log(nearest.name);
        calcAngle(window.myPlayer, nearest.player, nearest.distance)
    }

};
window.visiblePlayers = {};


//The game Does hack check, where if a hack is detected, it sets ur uuid to 255 which stiops u from doing damage
//what we do here is redefine the varaible to always return 0 so they can never flag us hehehe
Object.defineProperty(window, "uuid", {get: ()=>{return 0}});


//stuff from here on is code used to extract code from the games code, trippy right?
const request = url => fetch(url).then(res => res.text());
const injectInline = (data) => {
    let s = document.createElement('script');
    s.type = 'text/javascript';
    s.innerText = data;
    document.getElementsByTagName('head')[0].appendChild(s);
}


window.hexToRgb =(hex)=>{
    var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
    return result ? {
        r: parseInt(result[1], 16)/255,
        g: parseInt(result[2], 16)/255,
        b: parseInt(result[3], 16)/255,
        a: 1,
    } : null;
}

const attemptPatch = (source) => {
    const patches = new Map()


    //we get a copy of theg games code, and search for specific location. We found our player stuff and then call our external function where we can run our aimbot logic!
    .set("RENDERHOOK", [/var (\w+)=([a-zA-Z$]+)\(this\.mesh,\.(\d+)\);/, "rep = `var ${match[1]} = ${match[2]}(this.mesh,.31);window.visiblePlayers[this.player.id]=${match[1]};${match[1]}=true;this.bodyMesh.renderOverlay = !0;window.espColourSettings(this);`", true])
    .set("PLAYERHOOK", [/if\([^(\/.,)]+\)([^(\/.,)]+)\.actor\.update\([^(\/.,)]+\);/, false])
    .set("ENEMYHOOK", [/var [^(\/.,=]+\=([^(\/.,\[\]]+)\[[^(\/.,\[\]]\];[^(\/.,=&]+\&\&\([^(\/.,=]+\.chatLineCap/, false])
    .set("AIMBOTHOOK", [/[^(\/.,]+\([^(\/.,]+,[^(\/.,]+\/\d+\),[^(\/.,]+\.runRenderLoop\(\(function\(\)\{/, "rep = `${match[0]}window.doAimbot(${variables.PLAYERHOOK[1]}, ${variables.ENEMYHOOK[1]});`", true])

    variables = {};

    for (const [name, item] of patches) {
        let match = source.match(item[0]);

        if(!item[1]){
            if(match){
                variables[name] = match;
            }else{
                alert(`Failed to variable ${name}`);
                continue;
            }
        }else{
            let rep;
            try{
                eval(item[1]);
            }catch(e){
                alert(`Failed to patch ${name}`);
                continue;
            }
            console.log(rep);

            const patched = source.replace(item[0], rep);
            if (source === patched) {
                alert(`Failed to patch ${name}`);
                continue;
            } else console.log("Successfully patched ", name);
            source = patched;
        }
    }

    return source;
}

(async function() {
    let script = await request(`https://shellshock.io/src/shellshock.min.js`);
    console.log(script);
    injectInline(attemptPatch(script)) //modify the games code and then apply it :))
})();



//using a mutation observer oooohhh fancy ik! we can detect scripts before they run and patch them.
let observer = new MutationObserver(mutations => {

    for (const mutation of mutations) {

        for (let node of mutation.addedNodes) {

            if (node.tagName == 'HEAD') {
            } else if (node.tagName == 'SCRIPT' && node.src.includes("shellshock.min.js")) {
                node.outerHTML = ``
                //or we can make it point towards our own custom JS file...
                //node.src = "https://ourFileLocation/code.js"
            }
        }
    }
});

observer.observe(document, {
    childList: true,
    subtree: true
})

Can you get this code to work on the alt URL? (geometry.best)

you can just write under // @match ://shellshock.io/ this: // @match ://geometry.best/

if you guys don't know, this is for the tampermonkey extension, not to be pasted in the console. also this doesn't work for me

Can you get this code to work on the alt URL? (geometry.best)

you can just write under // @match ://shellshock.io/ this: // @match ://geometry.best/

yes

Um..............This doesnt work.

Try my script, it is inspired by this- https://greasyfork.org/en/scripts/489957-%E0%A6%94%E0%A7%A3%C9%A8n%C4%91%C9%A8%E2%B1%A5-%C5%A7%C5%82%C7%A5%C9%87%C9%BD%E0%A6%94%E0%A7%A3-aimbot-esp-for-shell-shockers