[NOT WORKING] Voxiom.io ESP & Tracers

Simple Voxiom Wallhacks

// ==UserScript==
// @name [NOT WORKING] Voxiom.io ESP & Tracers
// @require https://cdn.jsdelivr.net/npm/three@0.155.0/build/three.min.js#sha256-ec0a84377f1dce9d55b98f04ac7057376fa5371c33ab1cd907b85ae5f18fab7e
// @namespace https://github.com/oxygenvL
// @description Simple Voxiom Wallhacks
// @run-at document-start
// @match *://voxiom.io/*
// @author oxygenvi
// @version v1.2
// @grant none
// ==/UserScript==

let mainScene,
    cameras = [],
    THREE = window.THREE;
delete window.THREE; // Anti-Anti-Cheat

const calc3dDistance = (pos1, pos2) => Math.sqrt((pos2.x - pos1.x) ** 2 + (pos2.y - pos1.y) ** 2 + (pos2.z - pos1.z) ** 2);

WeakMap.prototype.set = new Proxy(WeakMap.prototype.set, {
    apply(target, prop, args) {
        const [object] = args;
        if (object.type === 'PerspectiveCamera') cameras.push(object);
        else if (object.isScene && object.type !== 'Scene' && object.children.length == 9) mainScene = object;
        return Reflect.apply(target, prop, args);
    }
});

window.requestAnimationFrame = new Proxy(window.requestAnimationFrame, {
    apply(target, prop, args) {
        mainScene?.children[5].children.filter((childObject => {
            const childObjectSet = new Set(childObject.children.map((childObjectChildren => childObjectChildren.type)));
            return childObjectSet.has('Mesh') && childObjectSet.has('Object3D');
        })).forEach(enemy => {
            const myCamera = cameras.find(camera => !camera.parent && camera.children.length === 1) || null;
            const enemyDistance = calc3dDistance(myCamera.position, enemy.position);
            const ESPHex = (new THREE.Color(0xff0000)).lerp(new THREE.Color(0x00ff00), Math.min(Math.max(enemyDistance, 0), 50) / 50).getHex();

            const enemyCharacterBox = enemy.children[1].children[3];
            const enemyBoundingBox = enemyCharacterBox.geometry.boundingBox;
            const enemyHeight = enemyBoundingBox.max.y - enemyBoundingBox.min.y;

            // Remove old ESPMesh
            if (typeof enemy.ESPMesh !== 'undefined') {
                enemy.remove(enemy.ESPMesh);
                delete enemy.ESPMesh;
            }

            // Create & Render ESPMesh
            const ESPMeshMaterial = new THREE.MeshBasicMaterial({ fog: false, depthTest: false, wireframe: enemyDistance < 150, });
            ESPMeshMaterial.color.setHex(ESPHex);

            let ESPMesh = new THREE.Mesh(new THREE.BoxGeometry, ESPMeshMaterial);
            ESPMesh.scale.set(0.4, 1.25, 0.4);
            ESPMesh.renderOrder = Infinity;
            ESPMesh.position.y += .65;

            enemy.ESPMesh = ESPMesh;
            enemy.add(ESPMesh);

            // Remove old ESPLine
            if (typeof enemy.ESPLine !== 'undefined') {
                mainScene.remove(enemy.ESPLine);
                delete enemy.ESPLine;
            }

            // Create & Render ESPLine
            const ESPLineMaterial = new THREE.LineBasicMaterial({ fog: false, depthTest: false, color: ESPHex, });
            ESPLineMaterial.needsUpdate = true;
            ESPLineMaterial.visible = true;

            const ESPLineTo = new THREE.Vector3(enemy.position.x, enemy.position.y + enemyHeight / 2, enemy.position.z);
            const ESPLineGeometry = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3().copy(myCamera.position), ESPLineTo]);
            ESPLineGeometry.attributes.position.setXYZ(0, myCamera.position.x, myCamera.position.y - 1, myCamera.position.z);
            ESPLineGeometry.attributes.position.setXYZ(1, enemy.position.x, enemy.position.y + enemyHeight / 2, enemy.position.z);
            ESPLineGeometry.attributes.position.needsUpdate = true;

            const ESPLine = new THREE.Line(ESPLineGeometry, ESPLineMaterial);
            ESPLine.renderOrder = Infinity;

            enemy.ESPLine = ESPLine;
            mainScene.add(ESPLine);
        });
        return Reflect.apply(target, prop, args);
    }
});