Shell Shockers Aim bot and ESP

Copy and paste the text below the dotted line into google extension "Violent monkey"
Link: https://chrome.google.com/webstore/detail/violentmonkey/jinjaccalgkegednnccohejagnlnfdag

-------------------------------------------------------

// ==UserScript==
// @name         Shellshock.IO Aimbot & ESP
// @namespace    http://tampermonkey.net/
// @version      0.3.1
// @description  Locks aim to the nearest player in shellshock.io. Comes with an ESP too. Press B, V, N, L to toggle aimbot, esp, esp lines, aimbot on right mouse hold.
// @author       Zainul-Aabidheen (Zain)
// @match        *://shellshock.io/*
// @grant        none
// @run-at       document-start
// ==/UserScript==

window.XMLHttpRequest = class extends window.XMLHttpRequest {
  open(method, url) {
    if (url.indexOf('shellshock.js') > -1) {
      this.isScript = true;
    }
    return super.open(...arguments);
  }

  get response() {
    if (this.isScript) {
      const code = super.response;
      let babylonVarName,
        playersVarName,
        myPlayerVarName,
        sceneVarName,
        cullFuncName;
      try {
        babylonVarName = /this\.origin=new ([a-zA-Z]+)\.Vector3/.exec(code)[1];
        playersVarName = /([^,]+)=\[\],[^,]+=\[\],{}/.exec(code)[1];
        myPlayerVarName = /"fire":document.pointerLockElement&&([^&]+)&&/.exec(code)[1];
        sceneVarName = /createMapCells\(([^,]+),/.exec(code)[1];
        cullFuncName = /=([a-zA-Z_$]+)\(this\.mesh,\.[0-9]+\)/.exec(code)[1];
      } catch (error) {
        alert('Script failed to inject. Report the issue to the script developer.\n' + JSON.stringify(getVars(), undefined, 2));
        return code;
      }

      function getVars() {
        return {
          babylonVarName,
          playersVarName,
          myPlayerVarName,
          playersVarName,
          sceneVarName,
          cullFuncName
        };
      }

      console.log('%cInjecting code...', 'color: red; background: black; font-size: 2em;', getVars());

      return code.replace(sceneVarName + '.render()', `
          window[ '${onUpdateFuncName}' ](
            ${babylonVarName},
            ${playersVarName},
            ${myPlayerVarName}
          );
          ${sceneVarName}.render()`)
        .replace(`function ${cullFuncName}`, `
          function ${cullFuncName}() {
            return true;
          }
          function someFunctionWhichWillNeverBeUsedNow`);
    }
    return super.response;
  }
};

let espEnabled = true;
let aimbotEnabled = true;
let showLines = true;
let aimbotOnRightMouse = false;

const temp = document.createElement('div');

temp.innerHTML = `<style>
.info {
  position: absolute;
  left: 50%;
  top: 50%;
  padding: 20px;
  background: rgba(0, 0, 0, 0.8);
  border: 6px solid rgba(0, 0, 0, 0.2);
  color: #fff;
  transform: translate(-50%, -50%);
  text-align: center;
  z-index: 999999;
  font-weight: bolder;
}
.info * {
  color: #fff;
}
.close-icon {
  position: absolute;
  right: 5px;
  top: 5px;
  width: 20px;
  height: 20px;
  opacity: 0.5;
  cursor: pointer;
}
.close-icon:before, .close-icon:after {
  content: ' ';
  position: absolute;
  left: 50%;
  top: 50%;
  width: 100%;
  height: 20%;
  transform: translate(-50%, -50%) rotate(-45deg);
  background: #fff;
}
.close-icon:after {
  transform: translate(-50%, -50%) rotate(45deg);
}
.close-icon:hover {
  opacity: 1;
}
.btn {
  cursor: pointer;
  padding: 0.5em;
  background: red;
  border: 3px solid rgba(0, 0, 0, 0.2);
}
.btn:active {
  transform: scale(0.8);
}
.msg {
  position: absolute;
  left: 10px;
  bottom: 10px;
  color: #fff;
  background: rgba(0, 0, 0, 0.6);
  font-weight: bolder;
  padding: 15px;
  animation: msg 0.5s forwards, msg 0.5s reverse forwards 3s;
  z-index: 999999;
  pointer-events: none;
}
@keyframes msg {
  from {
    transform: translate(-120%, 0);
  }
  to {
    transform: none;
  }
}
</style>
<div class="msg" style="display: none;"></div>
<div class="info">
  <div class="close-icon" onclick="this.parentNode.style.display='none';"></div>
  <big>== Aimbot & ESP ==</big>
  <br>
  <br>
  [B] to toggle aimbot
  <br>
  [V] to toggle ESP
  <br>
  [N] to toggle ESP Lines
  <br>
  [L] to toggle aimbot on <br>right mouse hold
  <br>
  [H] to show/hide help
  <br>
  <br>
  By Zain
  <br>
  <br>
</div>`;

const msgEl = temp.querySelector('.msg');
const infoEl = temp.querySelector('.info');

window.addEventListener('DOMContentLoaded', async function () {
  while (temp.children.length > 0) {
    document.body.appendChild(temp.children[0]);
  }
});

let rightMouseDown = false;

function handleMouse(event) {
  if (event.button === 2) {
    rightMouseDown = event.type === 'pointerdown' ? true : false;
  }
}

window.addEventListener('pointerdown', handleMouse);
window.addEventListener('pointerup', handleMouse);

window.addEventListener('keyup', function (event) {
  if (document.activeElement && document.activeElement.tagName === 'INPUT') {
    return;
  }

  switch (event.code) {
    case 'KeyB':
      aimbotEnabled = !aimbotEnabled;
      showMsg('Aimbot', aimbotEnabled);
      break;

    case 'KeyV':
      espEnabled = !espEnabled;
      showMsg('ESP', espEnabled);
      break;

    case 'KeyN':
      showLines = !showLines;
      showMsg('ESP Lines', showLines);
      break;

    case 'KeyH':
      infoEl.style.display = infoEl.style.display === '' ? 'none' : '';
      break;

    case 'KeyL':
      aimbotOnRightMouse = !aimbotOnRightMouse;
      showMsg('Aimbot On Right Mouse Hold', aimbotOnRightMouse);
      break;
  }
});

function showMsg(name, bool) {
  msgEl.innerText = name + ': ' + (bool ? 'ON' : 'OFF');
  msgEl.style.display = 'none';
  void msgEl.offsetWidth;
  msgEl.style.display = '';
}

let lineOrigin, lines;

const onUpdateFuncName = btoa(Math.random().toString(32));

window[onUpdateFuncName] = function (BABYLON, players, myPlayer) {
  if (!myPlayer) {
    return;
  }

  if (!lineOrigin) {
    lineOrigin = new BABYLON.Vector3();
    linesArray = [];
  }

  lineOrigin.copyFrom(myPlayer.actor.mesh.position);

  const yaw = myPlayer.actor.mesh.rotation.y;

  lineOrigin.x += Math.sin(yaw);
  lineOrigin.z += Math.cos(yaw);
  lineOrigin.y += Math.sin(-myPlayer.pitch);

  for (let i = 0; i < linesArray.length; i++) {
    linesArray[i].playerExists = false;
  }

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

    if (!player || player === myPlayer) {
      continue;
    }

    if (player.sphere === undefined) {
      console.log('Adding sphere...');
      const material = new BABYLON.StandardMaterial('myMaterial', player.actor.scene);
      material.emissiveColor = material.diffuseColor = new BABYLON.Color3(1, 0, 0);
      material.wireframe = true;

      const sphere = BABYLON.MeshBuilder.CreateBox('mySphere', { width: 0.5, height: 0.75, depth: 0.5 }, player.actor.scene);
      sphere.material = material;
      sphere.position.y = 0.3;

      sphere.parent = player.actor.mesh;

      player.sphere = sphere;
    }

    if (player.lines === undefined) {
      const options = {
        points: [lineOrigin, player.actor.mesh.position],
        updatable: true
      };

      const lines = options.instance = BABYLON.MeshBuilder.CreateLines('lines', options, player.actor.scene);
      lines.color = new BABYLON.Color3(1, 0, 0);
      lines.alwaysSelectAsActiveMesh = true;
      lines.renderingGroupId = 1;

      player.lines = lines;
      player.lineOptions = options;

      linesArray.push(lines);

      console.log('%cAdding line...', 'color: green; background: black; font-size: 2em;');
    }

    player.lines.playerExists = true;
    player.lines = BABYLON.MeshBuilder.CreateLines('lines', player.lineOptions);

    player.sphere.renderingGroupId = espEnabled ? 1 : 0;
    player.sphere.visibility = (aimbotEnabled || espEnabled) && myPlayer !== player && (myPlayer.team === 0 || myPlayer.team !== player.team);

    player.lines.visibility = player.playing && player.sphere.visibility && showLines;
  }

  for (let i = 0; i < linesArray.length; i++) {
    if (!linesArray[i].playerExists) {
      console.log('%cRemoving line...', 'color: red; background: black; font-size: 2em;');
      linesArray[i].dispose();
      linesArray.splice(i, 1);
    }
  }

  if (aimbotEnabled && (aimbotOnRightMouse ? rightMouseDown : true) && myPlayer.playing) {
    let minDistance = Infinity;
    let targetPlayer;

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

      if (player && player !== myPlayer && player.playing && (myPlayer.team === 0 || player.team !== myPlayer.team)) {
        const distance = Math.hypot(player.x - myPlayer.x, player.y - myPlayer.y, player.z - myPlayer.z);

        if (distance < minDistance) {
          minDistance = distance;
          targetPlayer = player;
        }
      }
    }

    if (targetPlayer) {
      const x = targetPlayer.actor.mesh.position.x - myPlayer.actor.mesh.position.x;
      const y = targetPlayer.actor.mesh.position.y - myPlayer.actor.mesh.position.y;
      const z = targetPlayer.actor.mesh.position.z - myPlayer.actor.mesh.position.z;

      myPlayer.yaw = Math.radAdd(Math.atan2(x, z), 0);
      myPlayer.pitch = -Math.atan2(y, Math.hypot(x, z)) % 1.5;
    }
  }
}