// ==UserScript==
// @name         Base Zones
// @description  credits to cazka for basically 99% of this script, no this is not a multiboxing script
// @version      1.2.2
// @author       none
// @match        *://diep.io/*
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addValueChangeListener
// @grant        GM_removeValueChangeListener
// @namespace https://greasyfork.org/users/790354
// @downloadURL none
// ==/UserScript==
'use strict';
function drawZones(x, y) {
    if (player.dead) return;
    if (player.gamemode === '4teams') {
    let r = 40;
    let corner1 = 0;
    let corner2 = 7750 / fov;
    ctx.save();
    ctx.globalAlpha = 0.04;
    //Calibration
    //Blue
    ctx.fillStyle = '#000000';
    ctx.beginPath();
    ctx.arc(corner1-x, corner1-y, 65, 0, 2*Math.PI);
    ctx.fill();
    //Purple
    ctx.fillStyle = '#000000';
    ctx.beginPath();
    ctx.arc(corner2-x, corner1-y, 65, 0, 2*Math.PI);
    ctx.fill();
    //Green
    ctx.fillStyle = '#000000';
    ctx.beginPath;
    ctx.arc(corner1-x, corner2-y, 65, 0, 2*Math.PI);
    ctx.fill();
    //Red
    ctx.fillStyle = '#000000';
    ctx.beginPath();
    ctx.arc(corner2-x, corner2-y, 65, 0, 2*Math.PI);
    ctx.fill();
    //Zone Rendering Outer
    //Blue
    ctx.fillStyle = '#006480';
    ctx.beginPath();
    ctx.arc(corner1-x, corner1-y, 65*r, 0, 2*Math.PI);
    ctx.fill();
    //Purple
    ctx.fillStyle = '#E461F2';
    ctx.beginPath();
    ctx.arc(corner2-x, corner1-y, 65*r, 0, 2*Math.PI);
    ctx.fill();
    //Green
    ctx.fillStyle = '#00803e';
    ctx.beginPath;
    ctx.arc(corner1-x, corner2-y, 65*r, 0, 2*Math.PI);
    ctx.fill();
    //Red
    ctx.fillStyle = '#963033';
    ctx.beginPath();
    ctx.arc(corner2-x, corner2-y, 65*r, 0, 2*Math.PI);
    ctx.fill();
    //Zone Rendering Inner
    ctx.globalAlpha = 0.12;
    //Blue
    ctx.fillStyle = '#006480';
    ctx.beginPath();
    ctx.arc(corner1-x, corner1-y, 45*r, 0, 2*Math.PI);
    ctx.fill();
    //Purple
    ctx.fillStyle = '#E461F2';
    ctx.beginPath();
    ctx.arc(corner2-x, corner1-y, 45*r, 0, 2*Math.PI);
    ctx.fill();
    //Green
    ctx.fillStyle = '#00803e';
    ctx.beginPath;
    ctx.arc(corner1-x, corner2-y, 45*r, 0, 2*Math.PI);
    ctx.fill();
    //Red
    ctx.fillStyle = '#963033';
    ctx.beginPath();
    ctx.arc(corner2-x, corner2-y, 45*r, 0, 2*Math.PI);
    ctx.fill();
    }
    ctx.restore();
}
class Minimap {
    constructor() {
        this._minimapWidth;
        this._minimapHeight;
        this._x00;
        this._y00;
        this._pointX;
        this._pointY;
        this._pointX_previous;
        this._pointY_previous;
        this._viewportWidth;
        this._viewportHeight;
        this._fov;

        this._minimapHook();
        this._arrowHook();
        this._viewportHook();
        this._fovHook();}
    get x() {
        return this._pointX ? (this._pointX - this._x00) / this._minimapWidth : 0;
    }
    get y() {
        return this._pointY ? (this._pointY - this._y00) / this._minimapHeight : 0;
    }
    get x_previous() {
        return this._pointX_previous ? (this._pointX_previous - this._x00) / this._minimapWidth : 0;
    }
    get y_previous() {
        return this._pointY_previous ? (this._pointY_previous - this._y00) / this._minimapHeight : 0;
    }
    get fov() {
        return this._fov;
    }

    _minimapHook() {
        let setTransformArgs;

        const onsetTransform = (args) => {
            if (args[0] === args[3]) setTransformArgs = args;
        };
        const onstrokeRect = () => {
            if (setTransformArgs) {
                this._minimapWidth = setTransformArgs[0];
                this._minimapHeight = setTransformArgs[3];
                this._x00 = setTransformArgs[4];
                this._y00 = setTransformArgs[5];
                setTransformArgs = undefined;
            }
        };
        this._ctxHook('setTransform', onsetTransform);
        this._ctxHook('strokeRect', onstrokeRect);
    }
    _arrowHook() {
        let index = 0;
        const stack = Array(4);

        let pointA;
        let pointB;
        let pointC;

        const calculatePos = () => {
            const side1 = Math.floor(
                Math.sqrt(Math.pow(pointA[0] - pointB[0], 2) + Math.pow(pointA[1] - pointB[1], 2))
            );
            const side2 = Math.floor(
                Math.sqrt(Math.pow(pointA[0] - pointC[0], 2) + Math.pow(pointA[1] - pointC[1], 2))
            );
            const side3 = Math.floor(
                Math.sqrt(Math.pow(pointB[0] - pointC[0], 2) + Math.pow(pointB[1] - pointC[1], 2))
            );
            if (side1 == side2 && side2 == side3) return;

            this._pointX_previous = this._pointX;
            this._pointY_previous = this._pointY;

            this._pointX = (pointA[0] + pointB[0] + pointC[0]) / 3;
            this._pointY = (pointA[1] + pointB[1] + pointC[1]) / 3;
        };
        const onbeginPath = () => {
            index = 0;
            stack[index++] = 0;
        };
        const onmoveTo = (args) => {
            if (index === 1 && stack[index - 1] === 0) {
                stack[index++] = 1;
                pointA = args;
                return;
            }
            index = 0;
        };
        const onlineTo = (args) => {
            if (index === 2 && stack[index - 1] === 1) {
                stack[index++] = 2;
                pointB = args;
                return;
            }
            if (index === 3 && stack[index - 1] === 2) {
                stack[index++] = 2;
                pointC = args;
                return;
            }
            index = 0;
        };
        const onfill = () => {
            if (index === 4 && stack[index - 1] === 2) {
                calculatePos();
                return;
            }
            index = 0;
        };

        this._ctxHook('beginPath', onbeginPath);
        this._ctxHook('moveTo', onmoveTo);
        this._ctxHook('lineTo', onlineTo);
        this._ctxHook('fill', onfill);
    }
    _viewportHook() {
        let setTransformArgs;

        const onsetTransform = (args) => {
            if ((args[0] / args[3]).toFixed(4) !== (unsafeWindow.innerWidth / unsafeWindow.innerHeight).toFixed(4)) return;
            if (args[0] >= unsafeWindow.innerWidth && args[3] >= unsafeWindow.innerHeight) return;
            setTransformArgs = args;
        };
        const onfillRect = () => {
            if (setTransformArgs) {
                unsafeWindow.input.set_convar('ren_minimap_viewport', true);
                this._viewportWidth = setTransformArgs[0];
                this._viewportHeight = setTransformArgs[3];
                setTransformArgs = undefined;
            }
        };

        this._ctxHook('setTransform', onsetTransform);
        this._ctxHook('fillRect', onfillRect);

        setInterval(() => {
            unsafeWindow.input.set_convar('ren_minimap_viewport', true);
        }, 1000);
    }
    _fovHook() {
        let solid_background = false;
        setTimeout(() => {
            solid_background = unsafeWindow.input.get_convar('ren_solid_background') === 'true' ? true : false;
        }, 1000);

        const calculateFov = (fov) => {
            this._fov = fov * 10;
        };
        function onstroke() {
            if (this.fillStyle === '#cdcdcd') {
                if (solid_background) unsafeWindow.input.set_convar('ren_solid_background', true);
                calculateFov(this.globalAlpha);
            }
        }

        this._ctxHook('stroke', onstroke);

        setInterval(() => {
            if (solid_background) unsafeWindow.input.set_convar('ren_solid_background', false);
        }, 10000);
    }
    _ctxHook(method, hook) {
        const target = window.CanvasRenderingContext2D.prototype;
        target[method] = new Proxy(target[method], {
            apply(target, thisArg, args) {
                args = hook.call(thisArg, args) || args;
                return target.apply(thisArg, args);
            },
        });
    }
}

class Player {
    constructor() {
        this._minimap = new Minimap();
        this._dead = true;

        //Dead Listener
        new MutationObserver((args) => {
            this._dead = args[0].target.style.display === 'block';
            if (this.ondead && this._dead) this.ondead();
        }).observe(document.getElementById('a'), { attributes: true });
    }
    get dead() {
        return this._dead;
    }
    get gamemode() {
        return unsafeWindow.localStorage.gamemode;
    }
}

const player = new Player();
const minimap = new Minimap();
const radius = 50;
const width = 149;
var arenaDim;
var scale,a,x,y,d,compensation;
var interX, interY, posX, posY, fov;
//setup canvas
const ctx = document.getElementById('canvas').getContext('2d');
// run main Loop

unsafeWindow.requestAnimationFrame = new Proxy(unsafeWindow.requestAnimationFrame, {
    apply: function (target, thisArg, args) {
        x = minimap._pointX;
        d = minimap._minimapWidth;
        scale = d / 181;
        fov = 1 / (Math.sqrt(player._minimap.fov * 2.5));
        arenaDim = 9000 / fov;
        y = minimap._pointY;
        compensation = a * 168;
        //Helpers
        if(window.innerHeight == screen.height) {
            a = 0;} else {a = 1;}
        interX = x - (1920-(198)*scale);
        interY = y - (1080-(206)*scale-compensation);
        posX = interX / d * arenaDim - 1580;
        posY = interY / d * arenaDim - 1580;
        drawZones(posX, posY);
        setTimeout(() => Reflect.apply(target, thisArg, args), 0);
    },
});