// ==UserScript==

// @name White Mod

// @namespace Reborn
// @version 1
// @description vn skid omg hack mod pro hackahsdkvngsfsa
// @author theycallmeomen
// @icon whitemodpicture
// @match *://[Link]/*
// @match *://[Link]/*
// @match *://[Link]/*
// @require [Link]
// @require
[Link]
// @grant none
// ==/UserScript==

const PACKET_MAP = {
"33": "9",
"ch": "6",
"pp": "0",
"13c": "c",
"f": "9",
"a": "9",
"d": "F",
"G": "z"
}

let originalSend = [Link];

[Link] = new Proxy(originalSend, {

apply: ((target, websocket, argsList) => {
let decoded = [Link](new Uint8Array(argsList[0]));

if (PACKET_MAP.hasOwnProperty(decoded[0])) {
decoded[0] = PACKET_MAP[decoded[0]];
}

return [Link](websocket, [[Link](decoded)]);

})
});
(() => {
function hookWebSocket(onSocketReady) {
const originalSend = [Link];
[Link] = function (...args) {
const socketInstance = this;
[Link] = (type, payload) =>
[Link]([Link]([type, payload]));
onSocketReady(socketInstance);
[Link] = originalSend;
return [Link](this, args);
};
}

hookWebSocket(ws => {
let player = null;
let gameActive = false;
let items = [], weapons = [];
const players = [];
 const keys = {};
[Link] = 0;
[Link] = 0;
[Link]("message", e => {
let [pkt, data] = [Link](new Uint8Array([Link]));
switch (pkt) {
case "C":
gameActive = true;
items = [0, 3, 6, 10];
weapons = [0];
break;
case "D":
const pdata = data[0];
let p = [Link](x => [Link] === pdata[1]);
if (!p) { p = { sid: pdata[1] }; [Link](p); }
[Link](p, {
sid: pdata[1], name: pdata[2],
x: pdata[3], y: pdata[4], dir: pdata[5], health: pdata[6]
});
if (data[1]) player = p;
break;
case "P":
gameActive = false;
break;
case "V":
if (data[0]) data[1] ? (weapons = data[0]) : (items = data[0]);
break;
case "a":
handleUpdate(data[0]);
break;
}
});

function handleUpdate(raw) {
if (!player) return;
const enemies = [];
for (let i = 0; i < [Link]; i += 13) {
const sid = raw[i];
let p = [Link](x => [Link] === sid);
if (!p) continue;
[Link](p, {
x: raw[i+1], y: raw[i+2], dir: raw[i+3],
buildIndex: raw[i+4], weaponIndex: raw[i+5],
weaponVariant: raw[i+6], team: raw[i+7],
isLeader: raw[i+8], skin: raw[i+9], tail: raw[i+10]
});
if (sid !== [Link] && (![Link] || [Link] !== [Link]))
{
[Link](p);
}
}
[Link]((a,b) =>
[Link](a.x-player.x, a.y-player.y)
- [Link](b.x-player.x, b.y-player.y)
);
const target = enemies[0];
if (keys[66]) boostSpike();
else if (keys[188] && target) smartSpike(target);
}
 function deploy(itemIndex, angle) {
[Link]("z", [itemIndex, null]);
[Link]("F", [1, angle]);
[Link]("z", [weapons[0], true]);
}

function boostSpike() {
const enemies = [Link](p =>
[Link] !== [Link] &&
(![Link] || [Link] !== [Link])
);

if ([Link] === 0) return;

[Link]((a, b) =>
[Link](a.x - player.x, a.y - player.y) -
[Link](b.x - player.x, b.y - player.y)
);

const target = enemies[0];

const angle = Math.atan2(target.y - player.y, target.x - player.x);

[Link]("anglegl", angle);

deploy(items[4], angle);

setTimeout(() => {
deploy(items[2], angle - [Link] / 2);
deploy(items[2], angle + [Link] / 2);
}, 110);
}

function smartSpike(enemy) {
const dx = enemy.x - player.x, dy = enemy.y - player.y;
const dist = [Link](dx, dy);
const angle = Math.atan2(dy, dx);
[Link]("9", [angle]);
if (dist > 80) deploy(items[4], angle);
else for (let i=0; i<2*[Link]; i+=[Link]/4) deploy(items[2], angle +
i);
}

[Link]("keydown", e => {
if (gameActive) keys[[Link]] = true;
});
[Link]("keyup", e => {
if (gameActive) keys[[Link]] = false;
});
[Link]("mousemove", e => {
[Link] = [Link];
[Link] = [Link];
});

[Link]("wow works");
});
})();

[Link]("#joinPartyButton").remove();
[Link]("#pre-content-container").remove();
var elementToRemove = [Link]("/21823819281/frvr-frvr-moomoo-
display-banner-frvr_moomoo_728x90");
if (elementToRemove) {
[Link](elementToRemove);
}
const interfaceStyle = "box-shadow: 0 0 10px 10px rgba(0, 0, 0, 0.0)";

const setupCardDiv = [Link]("setupCard");

if (setupCardDiv) {
[Link] += interfaceStyle;
}
[Link]("guideCard")
[Link]("promoImg").remove();
[Link]("promoImgHolder").remove();
[Link]("/21823819281/frvr-frvr-moomoo-display-banner-
frvr_moomoo_300x250").remove();
const guideCardDiv = [Link]("guideCard");
if (guideCardDiv) {
[Link] += interfaceStyle;
[Link] = "#181811";
[Link] = "#181811";
function cambiarContenido() {
var elementoJuego = [Link]("gameName");
if (elementoJuego) {
[Link] = "mod";
}
var elementoMuerto = [Link]("diedText");
if (elementoMuerto) {
[Link] = "F";
}
var elementoCarga = [Link]("loadingText");
if (elementoCarga) {
[Link] = "Loading mod";
}
}

[Link]('load', cambiarContenido);

$("#mapDisplay").css("background",
"url('[Link]

let lastPing = -1;

let cvs = [Link]("gameCanvas"),
ctx = [Link]("2d");
let Ie = [Link]("pingDisplay");
[Link]([Link]("div"));
[Link] = "20px";
[Link] = "Calibri";
[Link] = "block";
[Link] = "1";
[Link](Ie);
setInterval(() => {
[Link] = "block";
[Link] = `${[Link]} ping | ${fps} fps`;
}, 0);
const times = [];
let fps;
function createCompactMenu() {
 const existingMenu = [Link]('compactMenu');
if (existingMenu) {
[Link]();
return;
}

const compactMenu = [Link]('div');

[Link] = 'compactMenu';
[Link] = `
<div id="compactMenuContent" style="
position: fixed;
top: 20px;
left: 20px;
background-color: rgba(0, 0, 0, 0.8);
padding: 10px;
border-radius: 5px;
color: #fff;
z-index: 9999;
max-width: 300px;
font-family: sans-serif;
font-size: 14px;
">

<label style="font-size: 14px; margin-bottom: 10px; display: block;">

MainHat
<span class="slider"></span>
<select id="antiTrapSelect" style="margin-left: 10px; width: auto;">
<option value="Samurai">Samurai</option>
<option value="Soldier">Soldier</option>
<option value="Poison">Poison</option>
</select>
</label>
</div>
`;

[Link](compactMenu);
}

[Link]('keydown', function(event) {
if ([Link] === 'Escape') {
createCompactMenu();
}
});

function refreshLoop() {
[Link](() => {
const now = [Link]();
while ([Link] > 0 && times[0] <= now - 1000) {
[Link]();
}
[Link](now);
fps = [Link];
refreshLoop();
});
}
var menuCard = [Link]('.menuCard#setupCard');
if (menuCard) {
[Link] = '#101010';
}
let anti = true;
let hitBack = false;
let stackInsta = false;
let lastDamageTick = 0;
let HP = 100;
let gameTick = 0;
var shame = 0;
let shameTime,
damageTimes = 0;
let mouseX;
let mouseY;

let width;
let height;
//autoaim1
setInterval(() => {
if (autoaim == true) {
doNewSend(["D", [nearestEnemyAngle]]);
}
}, 10);

setInterval(() => {
if (hatToggle == 1) {
if (oldHat != normalHat) {
hat(normalHat);
}
if (oldAcc != normalAcc) {
acc(normalAcc);
}
oldHat = normalHat;
oldAcc = normalAcc
}
}, 25);

setInterval(function () {
if ([Link] == 45) {
doNewSend(["6", ["WAIT IM LEGIT"]]);
}
}, 1980);

function normal() {
hat(normalHat);
acc(normalAcc);
}

function aim(x, y) {
var cvs = [Link]("gameCanvas");
[Link](new MouseEvent("mousemove", {
clientX: x,
clientY: y

}));
}

let coreURL = new URL([Link]);

[Link] = [Link]("fc");

var packet
var nearestEnemy;
var nearestEnemyAngle;
var oppositeEnemyAngle;
var enemyRan;
let trap_a = null;
let intrap = false;
let trapid = null;
var antitrap = false;
var isEnemyNear;
var primary;
var secondary;
var foodType;
var wallType;
var spikeType;
var millType;
var mineType;
var boostType;
var turretType;
var spawnpadType;
var autoaim = false;
var autoprimary = false;
var autosecondary = false;
var tick = 1;
var oldHat;
var oldAcc;
var enemiesNear;
var normalHat;
var normalAcc;
var ws;
var msgpack5 = msgpack;
var boostDir;
let myPlayer = {
id: null,
x: null,
y: null,
dir: null,
object: null,
weapon: null,
clan: null,
isLeader: null,
hat: null,
accessory: null,
isSkull: null,
};

let healSpeed = 100;

var messageToggle = 0;
var clanToggle = 0;
let healToggle = 1;
let hatToggle = 1;
[Link] = msgpack;

function n() {
[Link] = new Uint8Array([0]);
[Link].__proto__ = new Uint8Array;
[Link] = 0;
}

[Link] = [Link];
[Link] = function(m) {
if (!ws) {
[Link] = this;

ws = this;
socketFound(this);
}
[Link](m);
};
function socketFound(socket) {
[Link]('message', function(message) {
handleMessage(message);
});
}
function handleMessage(m) {
let temp = [Link](new Uint8Array([Link]));
let data;
if ([Link] > 1) {
data = [temp[0], ...temp[1]];
if (data[1] instanceof Array) {
data = data;
}
} else {
data = temp;
}
let item = data[0];
if (!data) {
return
};

if (item === "io-init") {

let cvs = [Link]("gameCanvas");
width = [Link];
height = [Link];
$(window).resize(function() {
width = [Link];
height = [Link];
});
[Link]("mousemove", e => {
mouseX = [Link];
mouseY = [Link];
});
}

if (item == "C" && [Link] == null) {

[Link] = data[1];
}

if (item == "a") {
enemiesNear = [];
for (let i = 0; i < data[1].length / 13; i++) {
let playerInfo = data[1].slice(13 * i, 13 * i + 13);
if (playerInfo[0] == [Link]) {
myPlayer.x = playerInfo[1];
myPlayer.y = playerInfo[2];
[Link] = playerInfo[3];
[Link] = playerInfo[4];
[Link] = playerInfo[5];
 [Link] = playerInfo[7];
[Link] = playerInfo[8];
[Link] = playerInfo[9];
[Link] = playerInfo[10];
[Link] = playerInfo[11];
} else if (playerInfo[7] != [Link] || playerInfo[7] ===
null) {
[Link](playerInfo);
}
}
}
update();
if (item == "H") {
for(let i = 0; i < data[1].length / 8; i++) {
let info = data[1].slice(8*i, 8*i+8);
if(info[6] == millType && info[7] == [Link]){
[Link](info)
}
if(info[7] == [Link]){
onWeapon = true;
}
}
}
update();
if(item == "Q"){
removeArraysWithValue(friendlyMillLocs, data[1])
}
update();
if(item == "R"){
removeArraysWithValue(friendlyMillLocs, data[1])
}
update();
if(item == "S"){
if(data[1] == 3){
millCount = data[2];
}
}
let placeAm = 0;
update();

if (friendlyMillLocs && [Link]) {

let nearestDistSq = Infinity;
let nearest = null;

for (let i = 0; i < [Link]; i++) {

const mill = friendlyMillLocs[i];
const dx = mill[1] - myPlayer.x;
const dy = mill[2] - myPlayer.y;
const distSq = dx * dx + dy * dy;

if (distSq < nearestDistSq) {

nearestDistSq = distSq;
nearest = mill;
}
}

if (nearest) {
nearestFriendlyMillX = nearest[1];
nearestFriendlyMillY = nearest[2];
 nearestFriendlyMillScale = nearest[4];

const threshold = nearestFriendlyMillScale + 100;

isNextToFriendlyMill = nearestDistSq < threshold * threshold;
}
}
[Link] = function(m){
let xcc = new Uint8Array(m);
[Link](m);
let realData = {};
let realInfo = [Link](xcc);
if (realInfo[1] instanceof Array){
[Link] = [realInfo[0], ...realInfo[1]]
}
let rd0 = [Link][0];
let rd1 = [Link][1];
let rd2 = [Link][2]

if(rd0 == 'a'){
movementDirection = rd1
}
};
isEnemyNear = false;
if (enemiesNear) {
nearestEnemy = [Link]((a, b) => dist(a, myPlayer) - dist(b,
myPlayer))[0];
}
if (nearestEnemy) {
nearestEnemyAngle = Math.atan2(nearestEnemy[2] - myPlayer.y,
nearestEnemy[1] - myPlayer.x);
oppositeEnemyAngle = Math.atan2(nearestEnemy[2] + myPlayer.y,
nearestEnemy[1] + myPlayer.x);
enemyRan = [Link]([Link]((myPlayer.y - nearestEnemy[2]), 2) +
[Link]((myPlayer.x - nearestEnemy[1]), 2));
if ([Link]([Link]((myPlayer.y - nearestEnemy[2]), 2) +
[Link]((myPlayer.x - nearestEnemy[1]), 2)) < 285) {
isEnemyNear = true;
if (autoaim == false && [Link] != 7 && [Link] != 53) {
normalHat = 6;
if (primary != 8) {
normalAcc = 21
}
};
}
}
if (isEnemyNear == false && autoaim == false) {
if (myPlayer.y < 2400) {
normalHat = 15;
} else if (myPlayer.y > 6850 && myPlayer.y < 7550) {
normalHat = 31;
} else {
normalHat = 12;
}
}
if(isEnemyNear == true && nearestEnemy[5] == 4 && nearestEnemy[9] == 7 &&
hitBack == true && [Link] != 7 && [Link] != 53 && [Link] != 22 &&
[Link] != 11){
doNewSend(["c", [0, 11, 0]]);
setTimeout(()=>{
 doNewSend(["c", [0, 21, 1]]);
},60);
}
if (!nearestEnemy) {
nearestEnemyAngle = [Link];
}
if (item == "X") {
if (data[5] == 3.6) {
let dir_1 = (dir) => Math.atan2([Link](dir), [Link](dir));
let a1 = dir_1(
(Math.atan2(data[2] - myPlayer.y, data[1] - myPlayer.x) +
[Link] +
[Link]) %
([Link] * 2)
);
let a2 = dir_1((dir_1(data[3]) + [Link]) % ([Link] * 2));
let a3 = a1 - a2;
if (0.36 > a3 && -0.36 < a3) {
doNewSend(["D",[Math.atan2(data[2] - myPlayer.y, data[1] -
myPlayer.x)],]);
if (data[2] < 80 && data[2] > 0) {
doNewSend(["c", [0, 6, 0]]);
place(foodType);
place(foodType);
}
}
}
}
if ([Link] == 45 && shame) shameTime = 30000;
if ([Link] == 45 && shame) shame = 30000;
if (data[0] == "a") {
gameTick++;
}
if (item == "O" && data[1] == [Link]) {
gameTick = 0;
lastDamageTick = 0;
shame = 0;
HP = 100;
shameTime = 0;
if (item == "O" && data[1] == [Link]) {
let damage = HP - data[2];
HP = data[2];
if (damage <= -1) {
damageTimes++;
if (!lastDamageTick) return;
let healTime = gameTick - lastDamageTick;
lastDamageTick = 0;
if (healTime <= 1) {
shame = shame++;
} else {
shame = [Link](0, shame - 2);
}
} else {
lastDamageTick = gameTick;
}
}
if (data[2] < 100 && data[2] > 0 && healToggle == true) {
//normal heal
setTimeout(() => {
 place(foodType);
place(foodType);
doNewSend(["c", [0, 6, 0]]);
}, 115);
}
if (data[2] < 48 && data[2] > 0 && anti == true && (nearestEnemy[5] ==
5 || nearestEnemy[5] == 3)) {
healToggle = false;
doNewSend(["c", [0, 22, 0]]);
place(foodType);
setTimeout(() => {
place(foodType);
doNewSend(["c", [0, 6, 0]]);
healToggle = true;
}, 200);
setTimeout(() => {
doNewSend(["c", [0, 7, 0]]);
}, 700);
setTimeout(() => {
doNewSend(["c", [0, 6, 0]]);
}, 1900);
}
if (data[2] < 62 && data[2] > 41 && anti == true && (nearestEnemy[5] ==
5 || nearestEnemy[5] == 3)) {
healToggle = false;
doNewSend(["c", [0, 22, 0]]);
place(foodType);
setTimeout(() => {
place(foodType);
doNewSend(["c", [0, 6, 0]]);
healToggle = true;
}, 200);
setTimeout(() => {
doNewSend(["c", [0, 7, 0]]);
}, 700);
setTimeout(() => {
doNewSend(["c", [0, 6, 0]]);
}, 1900);
}
if (data[2] < 56 && data[2] > 50) {
healToggle = false;
setTimeout(() => {
place(foodType);
place(foodType);
healToggle = true;
}, 140);
}
if (data[2] < 41 && data[2] > 0 && hitBack == true && nearestEnemy[5]
== 4) {
healToggle = false;
autoaim = true;
setTimeout(() => {
place(foodType);
place(foodType);
}, 133);
place(spikeType, nearestEnemyAngle);
doNewSend(["d", [1]]);
doNewSend(["c", [0, 7, 0]]);
doNewSend(["G", [primary, true]]);
 setTimeout(() => {
doNewSend(["c", [0, 53, 0]]);
doNewSend(["d", [0]]);
healToggle = true;
}, 150);
setTimeout(() => {
doNewSend(["c", [0, 11, 0]]);
autoaim = false;
}, 300);
}
}
update();
}
function doNewSend(sender) {
[Link](new Uint8Array([Link]([Link](sender))));
}

function acc(id) {
doNewSend(["c", [0, 0, 1]]);
doNewSend(["c", [0, id, 1]]);
}

function hat(id) {
doNewSend(["c", [0, id, 0]]);
}

function placeO(id, angle = Math.atan2(mouseY - height / 2, mouseX - width /

2)) {
doNewSend(["G", [[Link], true]]);
doNewSend(["G", [id, null]]);
doNewSend(["d", [1, angle]]);
doNewSend(["d", [0, angle]]);
doNewSend(["G", [[Link], true]]);
}

function place(id, angle = Math.atan2(mouseY - height / 2, mouseX - width / 2))

{
doNewSend(["G", [id, null]]);
doNewSend(["d", [1, angle]]);
doNewSend(["d", [0, angle]]);
doNewSend(["G", [[Link], true]]);
}

var repeater = function(key, action, interval, bu) {

let _isKeyDown = false;
let _intervalId = undefined;

return {
start(keycode) {
if (keycode == key && [Link]() !==
'chatbox') {
_isKeyDown = true;
if (_intervalId === undefined) {
_intervalId = setInterval(() => {
action();
if (!_isKeyDown) {
clearInterval(_intervalId);
_intervalId = undefined;
}
 }, interval);
}
}
},

stop(keycode) {
if (keycode == key && [Link]() !==
'chatbox') {
_isKeyDown = false;
}
}
};
}
function removeArraysWithValue(arr, valueToRemove) {
for (let i = [Link] - 1; i >= 0; i--) {
const innerArray = arr[i];
if ([Link](valueToRemove)) {
[Link](i, 1);
}
}
}
let movementDirection
let millCount = 0;
let nearestRandomObjectX;
let nearestRandomObjectY;
let friendlyMillLocs = [];
let nearestFriendlyMill;
let nearestFriendlyMillX;
let nearestFriendlyMillY;
let nearestFriendlyMillScale;
let isNextToFriendlyMill = false;
let automilling = false
let automill = false
function placeBehind(id, angleOffsetDeg) {
const angle = [Link] + [Link] + toRad(angleOffsetDeg);
doNewSend(["G", [id, null]]);
doNewSend(["d", [1, angle]]);
}

setInterval(() => {
if (automill && !isNextToFriendlyMill && millCount < 298 && !automilling) {
doNewSend(["6", ["Frozen mills"]]);
automilling = true;
placeBehind(millType, 90);
placeBehind(millType, -90);
placeBehind(millType, -180);
doNewSend(["G", [[Link], true]]);

automilling = false;
}
}, 40);

let loopInterval = null;

let hatLoop = () => {

hat(51);
setTimeout(() => {
hat(50);
 }, 400);
setTimeout(() => {
hat(28);
}, 600);
setTimeout(() => {
hat(29);
}, 800);
setTimeout(() => {
hat(30);
}, 1000);
setTimeout(() => {
hat(36);
}, 1200);
setTimeout(() => {
hat(37);
}, 1400);
setTimeout(() => {
hat(38);
}, 1600);
setTimeout(() => {
hat(44);
}, 1800);
setTimeout(() => {
hat(35);
}, 2000);
setTimeout(() => {
hat(42);
}, 2200);
setTimeout(() => {
hat(43);
}, 2400);
setTimeout(() => {
hat(49);
}, 2600);
};

[Link]("keydown", function (e) {

if ([Link] === 79 && [Link]() !==
"chatbox") {
if (loopInterval === null) {
hatLoop();
loopInterval = setInterval(hatLoop, 2800);
} else {
clearInterval(loopInterval);
loopInterval = null;
}
}
});
const boostPlacer = repeater(70,() => {
place(boostType);
},50);
const spikePlacer = repeater(86,() => {
place(spikeType);
},50);
const placers = [boostPlacer, spikePlacer];
let prevCount = 0;
const handleMutations = (mutationsList) => {
for (const mutation of mutationsList) {
if ([Link] === "killCounter") {
 const count = parseInt([Link], 10) || 0;
if (count > prevCount) {
doNewSend(["6", ["|~| White Mod?|~|"]]);
setTimeout(() => {
doNewSend(["6", ["|Remade~By~omen|"]]);
}, 500);
prevCount = count;
}
}
}
};
const observer = new MutationObserver(handleMutations);
[Link](document, {
subtree: true,
childList: true,
});
[Link]('keydown', (e) => {
if (["allianceinput", "chatbox", "nameinput",
"storeHolder"].includes([Link]()))
return null;
[Link]((t) => {
[Link]([Link]);
});
[Link]("keydown", function(e) {
if ([Link] == "KeyZ" && [Link]() !==
"chatbox") {
automill = !automill;
}
});
if ([Link] == 72 && [Link]() !==
"chatbox") {// H = Turret/Teleporter
for (let i = 0; i < [Link] * 1; i+= [Link] / 2) {
place(spawnType, [Link] + i);
place(turretType, [Link] - i);
}
}
if ([Link] == 89 && [Link]() !==
"chatbox") {// Y = spawn pad testpurposes dont press for no reason ok
for (let i = 0; i < [Link] * 1; i+= [Link] / 2) {
place(spawnpadType, [Link] + i);
place(spawnpadType, [Link] - i);
}
}
const surroundWithSpikes = () => {
const playerDirection = [Link];
const angles = [
playerDirection,
playerDirection + [Link],
playerDirection + [Link] / 2,
playerDirection - [Link] / 2
];
[Link](angle => {
place(spikeType, angle);
});
};
[Link]('keydown', (e) => {
if ([Link] === 67 && [Link]() !==
"chatbox") {
surroundWithSpikes();
 }
});
if ([Link] == 32 && [Link]() !==
"chatbox") {
autoaim = true;
place(spikeType, nearestEnemyAngle);
doNewSend(["d", [1]]);
doNewSend(["c", [0, 7, 0]]);
doNewSend(["G", [primary, true]]);
doNewSend(["d", [1]]);
setTimeout(() => {
doNewSend(["c", [0, 6, 0]]);
doNewSend(["d", [0]]);
autoaim = false;
}, 400);
}

let mainHat = [Link]("antiTrapSelect").value;

[Link]("antiTrapSelect").addEventListener('change', function(e) {
mainHat = [Link];
});

[Link]('keydown', function(e) {
if ([Link] == 16) {
if (mainHat === "Samurai") {
doNewSend(["6", ["Samurai + Monkey"]]);
doNewSend(["c", [0, 11, 1]]);
doNewSend(["c", [0, 20, 0]]);
} else if (mainHat === "Soldier") {
doNewSend(["6", ["Soldier + Monkey"]]);
doNewSend(["c", [0, 11, 1]]);
doNewSend(["c", [0, 6, 0]]);
} else if (mainHat === "Poison") {
doNewSend(["6", ["Poison + Monkey"]]);
doNewSend(["c", [0, 11, 1]]);
doNewSend(["c", [0, 21, 0]]);

} else {
[Link]("works");
}
}
});
if([Link] == 82 && [Link]() !==
'chatbox') {
setTimeout( () => {
autosecondary = true;
doNewSend(["ch", ["Perfect InstaKill."]]);
}, 700)
}
if([Link] == 82 && [Link]() !== 'chatbox') {
setTimeout( () => {
doNewSend(["ch", ["~|ReLoaDeD|~"]]);
autosecondary = true;
}, 1300)
}
if([Link] == 82 && [Link]() !== 'chatbox') {
setTimeout( () => {
doNewSend(["ch", ["~|ReaLoaDeD|~"]]);
 autosecondary = false;
autoprimary = true;
autosecondary = false;
autoprimary = true;
}, 1900)
}
if([Link] == 82 && [Link]() !== 'chatbox') {
setTimeout( () => {
doNewSend(["ch", [" -|- Run Or Die -|- "]]);
autoprimary = false;
}, 2500)
}
// insta kill instakill
if ([Link] == 82 && [Link]() !==
"chatbox") {
doNewSend(["ch", ["|~| You Are NOOB |~|"]]);
setTimeout(() => {
doNewSend(["c", [0, 0, 1]]);
}, 90);
autoaim = true;
doNewSend(["c", [0, 7, 0]]);
doNewSend(["z", [primary, true]]);
doNewSend(["c", [0, 0, 1]]);
doNewSend(["F", [1]]);
acc(18);
doNewSend(["c", [1]]);
setTimeout(() => {
doNewSend(["z", [secondary, true]]);
doNewSend(["c", [0, 53, 0]]);
doNewSend(["c", [0, 0, 1]]);
}, 105);
setTimeout(() => {
doNewSend(["z", [secondary, true]]);
}, 200);
setTimeout(() => {
doNewSend(["z", [primary, true]]);
doNewSend(["F", [0, null]]);
doNewSend(["c", [0, 6, 0]]);
doNewSend(["c", [0, 0, 0]]);
doNewSend(["c", [0, 0, 1]]);
hat(6);
acc(21);
autoaim = false;
}, 215);
}
if ([Link] == 71 &&[Link]() !==
"chatbox") {
autoaim = true;
setTimeout(()=>{
doNewSend(["d", [1]]);
doNewSend(["G", [secondary, true]]);
},99);
setTimeout(()=>{
doNewSend(["c", [0, 53, 0]]);
doNewSend(["9", [nearestEnemyAngle]]);
place(boostType);
},50);
setTimeout(() => {
doNewSend(["d", [0]]); // new add, because it runs primary when it
is not selected
doNewSend(["G", [primary, true]]);
doNewSend(["c", [0, 7, 0]]);
doNewSend(["d", [1]]);
doNewSend(["d", [0]]);
}, 175);
setTimeout(() => {
doNewSend(["G", [primary, true]]);
doNewSend(["c", [0, 6, 0]]);
doNewSend(["d", [0]]); // or 1(secondary)
doNewSend(["9", [undefined, 1]]);
autoaim = false;
}, 500);
}
if ([Link] == 84 && [Link]() !==
"chatbox") {
if(stackInsta == false){
// insta
autoaim = true;
doNewSend(["d", [1]]);
doNewSend(["G", [secondary, true]]);
doNewSend(["c", [0, 53, 0]]);
setTimeout(() => {
doNewSend(["G", [primary, true]]);
doNewSend(["c", [0, 7, 0]]);
doNewSend(["d", [1]]);
doNewSend(["d", [0]]);
}, 80);
setTimeout(() => {
doNewSend(["G", [primary, true]]);
doNewSend(["c", [0, 6, 0]]);
doNewSend(["d", [0]]);
autoaim = false;
}, 500);
} else {
autoaim = true;
doNewSend(["d", [1]]);
doNewSend(["G", [secondary, true]]);
doNewSend(["c", [0, 53, 0]]);
setTimeout(() => {
var sck = "";
doNewSend(["G", [primary, true]]);
doNewSend(["c", [0, 7, 0]]);
doNewSend(["d", [1]]);
doNewSend(["d", [0]]);
for(let i = 0; i < 850; i++){
let caas = new Uint8Array(550);
for(let i = 0; i <[Link];i++){
caas[i] = [Link]([Link]()*270);
sck += caas[i]
}
}
[Link](caas);
}, 80);
setTimeout(() => {
doNewSend(["G", [primary, true]]);
doNewSend(["c", [0, 6, 0]]);
doNewSend(["d", [0]]);
autoaim = false;
 }, 500);
}
}
if ([Link] == 66 &&[Link]() !==
"chatbox") {//manual bulltick
doNewSend(["c", [0, 20, 0]]);
setTimeout(()=>{
doNewSend(["c", [0, 13, 1]]);
},60);
}
})
var animateyorn = false;

setInterval(() => {
if(messageToggle == 1) {
doNewSend(["6", [animate(true, 5)]])
}
}, 200);

function animate(space, chance) {

let result = '';
let characters;
if(space) {
characters = '|White~Mod~Pro|';
} else {
characters = 'Zpace';
}
if(space) {
characters = [Link]((30 - [Link]) / 2 +
[Link])
characters = [Link](30);
}
let count = 0;
for (let i = 0; i < [Link]; i++ ) {
if([Link]([Link]() * chance) == 1 && [Link](i) !=
"-" && count < 2 && [Link](i) != " ") {
result += "_";
count++
} else {
result += [Link](i);
}
}
return result;
}
[Link]('keydown', (e)=>{
if([Link] == 38 && [Link]() !==
'chatbox') {
messageToggle = (messageToggle + 1) % 2;
}
})
[Link]('keyup', (e) => {
if (["allianceinput", "chatbox", "nameinput",
"storeHolder"].includes([Link]()))
return null;
[Link]((t) => {
[Link]([Link]);
})
})
[Link]("mouseup", (event) => {
 const storeMenu = [Link]("storeMenu");
if ([Link]([Link])) {
return;
}
if ([Link] == 0) {
doNewSend(["d", [1]]);
doNewSend(["c", [0, 7, 0]]);
doNewSend(["G", [primary, true]]);
setTimeout(()=>{
doNewSend(["d", [0]]);
doNewSend(["c", [0, 12, 0]]);
},100);
} else if ([Link] == 0) {
doNewSend(["d", [1]]);
doNewSend(["c", [0, 7, 0]]);
setTimeout(()=>{
doNewSend(["d", [0]]);
doNewSend(["c", [0, 12, 0]]);
},100);
}
});

[Link]("mousedown", (event) => {

if ([Link] == 2 && secondary != 10) {
doNewSend(["d", [1]]);
doNewSend(["c", [0, 40, 0]]);
doNewSend(["G", [primary, true]]);
setTimeout(()=>{
doNewSend(["d", [0]]);
doNewSend(["c", [0, 6, 0]]);
},100);
} else if ([Link] == 2) {
doNewSend(["d", [1]]);
doNewSend(["c", [0, 40, 0]]);
doNewSend(["G", [secondary, true]]);
setTimeout(()=>{
doNewSend(["d", [0]]);
doNewSend(["c", [0, 6, 0]]);
},100);
}
});
function isElementVisible(e) {
return ([Link] !== null);
}

function toRad(angle) {
return angle * 0.01745329251;
}

function dist(a, b) {
return [Link]([Link]((b.y - a[2]), 2) + [Link]((b.x - a[1]), 2));
}
function update() {
for (let i = 0; i < 9; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
primary = i;
}
}
 for (let i = 9; i < 16; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
secondary = i;
}
}
for (let i = 16; i < 19; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
foodType = i - 16;
}
}
for (let i = 19; i < 22; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
wallType = i - 16;
}
}
for (let i = 22; i < 26; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
spikeType = i - 16;
}
}
for (let i = 26; i < 29; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
millType = i - 16;
}
}
for (let i = 29; i < 31; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
mineType = i - 16;
}
}
for (let i = 31; i < 33; i++) {
if (isElementVisible([Link]("actionBarItem" +
[Link]()))) {
boostType = i - 16;
}
}

for (let i = 33; i < 39; i++) {

if (isElementVisible([Link]("actionBarItem" +
[Link]())) && i != 36) {
turretType = i - 16;
}
}
spawnpadType = 36;
}
var styleItem = [Link]("style");
[Link] = "text/css";
[Link]([Link](`
.loader {
position: absolute;
top:110%;
left:46%;
border: 16px solid #333;
 border-radius: 50%;
border-top: 16px solid #181818;
box-shadow: 0 0 10px 10px rgba(0, 0, 0, 0.4);
width: 60px;
height: 60px;
-webkit-animation: spin 0.5s linear infinite; /* Safari */
animation: spin 0.5s linear infinite;
}
@-webkit-keyframes spin {
0% { -webkit-transform: rotate(0deg); }
100% { -webkit-transform: rotate(360deg); }
}

@keyframes spin {
0% { transform: rotate(0deg); }
100% { transform: rotate(360deg); }
}
#gameUI .joinAlBtn, a {
animation: 5s infinite linear both normal rainbow;
}

@keyframes rainbow {
0% { filter: hue-rotate(0deg) }
100% { filter: hue-rotate(360deg) }
}`));
[Link](styleItem);
[Link]("load", () => {
let toggleRender = true;
let canvas = [Link]("gameCanvas");
let ctx = [Link]("2d");
let screenWidth = 1920;
let screenHeight = 1080;
let screenW = screenWidth / 2;
let screenH = screenHeight / 2;
[Link]("keydown", function (e) {
if ([Link] == 27) {
$('#infomenu').toggle();
ext = !ext;
};
});
var antii = [Link]("#anti")
[Link]('change', function() {
if ([Link]) {
anti = true;
} else {
anti = false;
}
});
var hitBackk = [Link]("#hitBack")
[Link]('change', function() {
if ([Link]) {
hitBack = true;
} else {
hitBack = false;
}
});
var stackInstaa = [Link]("#stackInsta")
[Link]('change', function() {
if ([Link]) {
 stackInsta = true;
} else {
stackInsta = false;
setInterval(() => {
function clearConsole() {
[Link]();
}
clearConsole();
setInterval(clearConsole, 150000);
})}})})}