NOTICE: By continued use of this site you understand and agree to the binding Terms of Service and Privacy Policy.
// ==UserScript==
// @name AposBot for Agar.io
// @namespace AposBot for Agar.io
// @include http://agar.io/
// @version 3.18
// @grant none
// @author Vance
// ==/UserScript==
Number.prototype.mod = function(n) {
return ((this % n) + n) % n;
};
Array.prototype.peek = function() {
return this[this.length - 1];
};
$.get('https://raw.githubusercontent.com/Apostolique/Agar.io-bot/master/bot.user.js?1', function(data) {
var latestVersion = data.replace(/(\r\n|\n|\r)/gm,"");
latestVersion = latestVersion.substring(latestVersion.indexOf("// @version")+11,latestVersion.indexOf("// @grant"));
latestVersion = parseFloat(latestVersion + 0.0000);
var myVersion = parseFloat(GM_info.script.version + 0.0000);
if(latestVersion > myVersion)
{
alert("Update Available for bot.user.js: V" + latestVersion + "\nGet the latest version from the GitHub page.");
window.open('https://github.com/Apostolique/Agar.io-bot/blob/master/bot.user.js','_blank');
}
console.log('Current bot.user.js Version: ' + myVersion + " on Github: " + latestVersion);
});
console.log("Running Apos Bot!");
(function(f, g) {
var splitDistance = 710;
console.log("Apos Bot!");
if (f.botList == null) {
f.botList = [];
g('#locationUnknown').append(g('<select id="bList" class="form-control" onchange="setBotIndex($(this).val());" />'));
g('#locationUnknown').addClass('form-group');
}
f.botList.push(["AposBot", findDestination]);
var bList = g('#bList');
g('<option />', {value: (f.botList.length - 1), text: "AposBot"}).appendTo(bList);
//Given an angle value that was gotten from valueAndleBased(),
//returns a new value that scales it appropriately.
function paraAngleValue(angleValue, range) {
return (15 / (range[1])) * (angleValue * angleValue) - (range[1] / 6);
}
function valueAngleBased(angle, range) {
var leftValue = (angle - range[0]).mod(360);
var rightValue = (rangeToAngle(range) - angle).mod(360);
var bestValue = Math.min(leftValue, rightValue);
if (bestValue <= range[1]) {
return paraAngleValue(bestValue, range);
}
var banana = -1;
return banana;
}
function computeDistance(x1, y1, x2, y2) {
var xdis = x1 - x2; // <--- FAKE AmS OF COURSE!
var ydis = y1 - y2;
var distance = Math.sqrt(xdis * xdis + ydis * ydis);
return distance;
}
function computerDistanceFromCircleEdge(x1, y1, x2, y2, s2) {
var tempD = computeDistance(x2, y2, x1, y1);
var offsetX = 0;
var offsetY = 0;
var ratioX = tempD / (x2 - x1);
var ratioY = tempD / (y2 - y1);
offsetX = x2 - (s2 / ratioX);
offsetY = y2 - (s2 / ratioY);
return computeDistance(x1, y1, offsetX, offsetY);
}
function getListBasedOnFunction(booleanFunction, listToUse) {
var dotList = [];
var interNodes = getMemoryCells();
Object.keys(listToUse).forEach(function(element, index) {
if (booleanFunction(element)) {
dotList.push(interNodes[element]);
}
});
return dotList;
}
function compareSize(player1, player2, ratio) {
if (player1.size * player1.size * ratio < player2.size * player2.size) {
return true;
}
return false;
}
function canSplit(player1, player2) {
return compareSize(player1, player2, 2.30) && !compareSize(player1, player2, 9);
}
function processEverything(listToUse) {
Object.keys(listToUse).forEach(function(element, index) {
computeAngleRanges(listToUse[element], getPlayer()[0]);
});
}
function getAll() {
var dotList = [];
var player = getPlayer();
var interNodes = getMemoryCells();
dotList = getListBasedOnFunction(function(element) {
var isMe = false;
for (var i = 0; i < player.length; i++) {
if (interNodes[element].id == player[i].id) {
isMe = true;
break;
}
}
if (!isMe) {
return true;
}
return false;
}, interNodes);
return dotList;
}
function getAllViruses(blob) {
var dotList = [];
var player = getPlayer();
var interNodes = getMemoryCells();
dotList = getListBasedOnFunction(function(element) {
var isMe = false;
for (var i = 0; i < player.length; i++) {
if (interNodes[element].id == player[i].id) {
isMe = true;
break;
}
}
if (!isMe && interNodes[element].d && compareSize(interNodes[element], blob, 1.30)) {
return true;
}
return false;
}, interNodes);
return dotList;
}
function getAllThreats(blob) {
var dotList = [];
var player = getPlayer();
var interNodes = getMemoryCells();
dotList = getListBasedOnFunction(function(element) {
var isMe = false;
for (var i = 0; i < player.length; i++) {
if (interNodes[element].id == player[i].id) {
isMe = true;
break;
}
}
if (!isMe && (!interNodes[element].d && compareSize(blob, interNodes[element], 1.30))) {
return true;
}
return false;
}, interNodes);
return dotList;
}
function getAllFood(blob) {
var elementList = [];
var dotList = [];
var player = getPlayer();
var interNodes = getMemoryCells();
elementList = getListBasedOnFunction(function(element) {
var isMe = false;
for (var i = 0; i < player.length; i++) {
if (interNodes[element].id == player[i].id) {
isMe = true;
break;
}
}
if (!isMe && !interNodes[element].d && compareSize(interNodes[element], blob, 1.30) || (interNodes[element].size <= 11)) {
return true;
} else {
return false;
}
}, interNodes);
for (var i = 0; i < elementList.length; i++) {
dotList.push([elementList[i].x, elementList[i].y, elementList[i].size]);
}
return dotList;
}
function clusterFood(foodList, blobSize) {
var clusters = [];
var addedCluster = false;
//1: x
//2: y
//3: size or value
//4: Angle, not set here.
for (var i = 0; i < foodList.length; i++) {
for (var j = 0; j < clusters.length; j++) {
if (computeDistance(foodList[i][0], foodList[i][1], clusters[j][0], clusters[j][1]) < blobSize * 1.5) {
clusters[j][0] = (foodList[i][0] + clusters[j][0]) / 2;
clusters[j][1] = (foodList[i][1] + clusters[j][1]) / 2;
clusters[j][2] += foodList[i][2];
addedCluster = true;
break;
}
}
if (!addedCluster) {
clusters.push([foodList[i][0], foodList[i][1], foodList[i][2], 0]);
}
addedCluster = false;
}
return clusters;
}
function getAngle(x1, y1, x2, y2) {
//Handle vertical and horizontal lines.
if (x1 == x2) {
if (y1 < y2) {
return 271;
//return 89;
} else {
return 89;
}
}
return (Math.round(Math.atan2(-(y1 - y2), -(x1 - x2)) / Math.PI * 180 + 180));
}
function slope(x1, y1, x2, y2) {
var m = (y1 - y2) / (x1 - x2);
return m;
}
function slopeFromAngle(degree) {
if (degree == 270) {
degree = 271;
} else if (degree == 90) {
degree = 91;
}
return Math.tan((degree - 180) / 180 * Math.PI);
}
//Given two points on a line, finds the slope of a perpendicular line crossing it.
function inverseSlope(x1, y1, x2, y2) {
var m = slope(x1, y1, x2, y2);
return (-1) / m;
}
//Given a slope and an offset, returns two points on that line.
function pointsOnLine(slope, useX, useY, distance) {
var b = useY - slope * useX;
var r = Math.sqrt(1 + slope * slope);
var newX1 = (useX + (distance / r));
var newY1 = (useY + ((distance * slope) / r));
var newX2 = (useX + ((-distance) / r));
var newY2 = (useY + (((-distance) * slope) / r));
return [
[newX1, newY1],
[newX2, newY2]
];
}
function followAngle(angle, useX, useY, distance) {
var slope = slopeFromAngle(angle);
var coords = pointsOnLine(slope, useX, useY, distance);
var side = (angle - 90).mod(360);
if (side < 180) {
return coords[1];
} else {
return coords[0];
}
}
//Using a line formed from point a to b, tells if point c is on S side of that line.
function isSideLine(a, b, c) {
if ((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]) > 0) {
return true;
}
return false;
}
//angle range2 is within angle range2
//an Angle is a point and a distance between an other point [5, 40]
function angleRangeIsWithin(range1, range2) {
if (range2[0] == (range2[0] + range2[1]).mod(360)) {
return true;
}
//console.log("r1: " + range1[0] + ", " + range1[1] + " ... r2: " + range2[0] + ", " + range2[1]);
var distanceFrom0 = (range1[0] - range2[0]).mod(360);
var distanceFrom1 = (range1[1] - range2[0]).mod(360);
if (distanceFrom0 < range2[1] && distanceFrom1 < range2[1] && distanceFrom0 < distanceFrom1) {
return true;
}
return false;
}
function angleRangeIsWithinInverted(range1, range2) {
var distanceFrom0 = (range1[0] - range2[0]).mod(360);
var distanceFrom1 = (range1[1] - range2[0]).mod(360);
if (distanceFrom0 < range2[1] && distanceFrom1 < range2[1] && distanceFrom0 > distanceFrom1) {
return true;
}
return false;
}
function angleIsWithin(angle, range) {
var diff = (rangeToAngle(range) - angle).mod(360);
if (diff >= 0 && diff <= range[1]) {
return true;
}
return false;
}
function rangeToAngle(range) {
return (range[0] + range[1]).mod(360);
}
function anglePair(range) {
return (range[0] + ", " + rangeToAngle(range) + " range: " + range[1]);
}
function computeAngleRanges(blob1, blob2) {
var mainAngle = getAngle(blob1.x, blob1.y, blob2.x, blob2.y);
var leftAngle = (mainAngle - 90).mod(360);
var rightAngle = (mainAngle + 90).mod(360);
var blob1Left = followAngle(leftAngle, blob1.x, blob1.y, blob1.size);
var blob1Right = followAngle(rightAngle, blob1.x, blob1.y, blob1.size);
var blob2Left = followAngle(rightAngle, blob2.x, blob2.y, blob2.size);
var blob2Right = followAngle(leftAngle, blob2.x, blob2.y, blob2.size);
var blob1AngleLeft = getAngle(blob2.x, blob2.y, blob1Left[0], blob1Left[1]);
var blob1AngleRight = getAngle(blob2.x, blob2.y, blob1Right[0], blob1Right[1]);
var blob2AngleLeft = getAngle(blob1.x, blob1.y, blob2Left[0], blob2Left[1]);
var blob2AngleRight = getAngle(blob1.x, blob1.y, blob2Right[0], blob2Right[1]);
var blob1Range = (blob1AngleRight - blob1AngleLeft).mod(360);
var blob2Range = (blob2AngleRight - blob2AngleLeft).mod(360);
var tempLine = followAngle(blob2AngleLeft, blob2Left[0], blob2Left[1], 400);
//drawLine(blob2Left[0], blob2Left[1], tempLine[0], tempLine[1], 0);
if ((blob1Range / blob2Range) > 1) {
drawPoint(blob1Left[0], blob1Left[1], 3, "");
drawPoint(blob1Right[0], blob1Right[1], 3, "");
drawPoint(blob1.x, blob1.y, 3, "" + blob1Range + ", " + blob2Range + " R: " + (Math.round((blob1Range / blob2Range) * 1000) / 1000));
}
//drawPoint(blob2.x, blob2.y, 3, "" + blob1Range);
}
function debugAngle(angle, text) {
var player = getPlayer();
var line1 = followAngle(angle, player[0].x, player[0].y, 300);
drawLine(player[0].x, player[0].y, line1[0], line1[1], 5);
drawPoint(line1[0], line1[1], 5, "" + text);
}
function getEdgeLinesFromPoint(blob1, blob2) {
// find tangents
//
// TODO: DON'T FORGET TO HANDLE IF BLOB1'S CENTER POINT IS INSIDE BLOB2!!!
var px = blob1.x;
var py = blob1.y;
var cx = blob2.x;
var cy = blob2.y;
var radius = blob2.size;
if (blob2.d) {
radius = blob1.size;
} else if(canSplit(blob1, blob2)) {
radius += splitDistance;
} else {
radius += blob1.size * 2;
}
var shouldInvert = false;
if (computeDistance(px, py, cx, cy) <= radius) {
radius = computeDistance(px, py, cx, cy) - 5;
shouldInvert = true;
}
var dx = cx - px;
var dy = cy - py;
var dd = Math.sqrt(dx * dx + dy * dy);
var a = Math.asin(radius / dd);
var b = Math.atan2(dy, dx);
var t = b - a;
var ta = {
x: radius * Math.sin(t),
y: radius * -Math.cos(t)
};
t = b + a;
var tb = {
x: radius * -Math.sin(t),
y: radius * Math.cos(t)
};
var angleLeft = getAngle(cx + ta.x, cy + ta.y, px, py);
var angleRight = getAngle(cx + tb.x, cy + tb.y, px, py);
var angleDistance = (angleRight - angleLeft).mod(360);
if (shouldInvert) {
var temp = angleLeft;
angleLeft = (angleRight + 180).mod(360);
angleRight = (temp + 180).mod(360);
angleDistance = (angleRight - angleLeft).mod(360);
}
return [angleLeft, angleDistance, [cx + tb.x, cy + tb.y],
[cx + ta.x, cy + ta.y]
];
}
function invertAngle(range) {
var angle1 = rangeToAngle(badAngles[i]);
var angle2 = (badAngles[i][0] - angle1).mod(360);
return [angle1, angle2];
}
function addWall(listToUse, blob) {
if (blob.x < f.getMapStartX() + 1000) {
//LEFT
//console.log("Left");
listToUse.push([[135, true], [225, false]]);
var lineLeft = followAngle(135, blob.x, blob.y, 190 + blob.size);
var lineRight = followAngle(225, blob.x, blob.y, 190 + blob.size);
drawLine(blob.x, blob.y, lineLeft[0], lineLeft[1], 5);
drawLine(blob.x, blob.y, lineRight[0], lineRight[1], 5);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob.x, blob.y, 5);
}
if (blob.y < f.getMapStartY() + 1000) {
//TOP
//console.log("TOP");
listToUse.push([[225, true], [315, false]]);
var lineLeft = followAngle(225, blob.x, blob.y, 190 + blob.size);
var lineRight = followAngle(315, blob.x, blob.y, 190 + blob.size);
drawLine(blob.x, blob.y, lineLeft[0], lineLeft[1], 5);
drawLine(blob.x, blob.y, lineRight[0], lineRight[1], 5);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob.x, blob.y, 5);
}
if (blob.x > f.getMapEndX() - 1000) {
//RIGHT
//console.log("RIGHT");
listToUse.push([[315, true], [45, false]]);
var lineLeft = followAngle(315, blob.x, blob.y, 190 + blob.size);
var lineRight = followAngle(45, blob.x, blob.y, 190 + blob.size);
drawLine(blob.x, blob.y, lineLeft[0], lineLeft[1], 5);
drawLine(blob.x, blob.y, lineRight[0], lineRight[1], 5);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob.x, blob.y, 5);
}
if (blob.y > f.getMapEndY() - 1000) {
//BOTTOM
//console.log("BOTTOM");
listToUse.push([[45, true], [135, false]]);
var lineLeft = followAngle(45, blob.x, blob.y, 190 + blob.size);
var lineRight = followAngle(135, blob.x, blob.y, 190 + blob.size);
drawLine(blob.x, blob.y, lineLeft[0], lineLeft[1], 5);
drawLine(blob.x, blob.y, lineRight[0], lineRight[1], 5);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob.x, blob.y, 5);
}
return listToUse;
}
//listToUse contains angles in the form of [angle, boolean].
//boolean is true when the range is starting. False when it's ending.
//range = [[angle1, true], [angle2, false]]
function getAngleIndex(listToUse, angle) {
if (listToUse.length == 0) {
return 0;
}
for (var i = 0; i < listToUse.length; i++) {
if (angle <= listToUse[i][0]) {
return i;
}
}
return listToUse.length;
}
function addAngle(listToUse, range) {
//#1 Find first open element
//#2 Try to add range1 to the list. If it is within other range, don't add it, set a boolean.
//#3 Try to add range2 to the list. If it is withing other range, don't add it, set a boolean.
//TODO: Only add the new range at the end after the right stuff has been removed.
var startIndex = 1;
if (listToUse.length > 0 && !listToUse[0][1]) {
startIndex = 0;
}
var startMark = getAngleIndex(listToUse, range[0][0]);
var startBool = startMark.mod(2) != startIndex;
var endMark = getAngleIndex(listToUse, range[1][0]);
var endBool = endMark.mod(2) != startIndex;
var removeList = [];
if (startMark != endMark) {
//Note: If there is still an error, this would be it.
var biggerList = 0;
if (endMark == listToUse.length) {
biggerList = 1;
}
for (var i = startMark; i < startMark + (endMark - startMark).mod(listToUse.length + biggerList); i++) {
removeList.push((i).mod(listToUse.length));
}
} else if (startMark < listToUse.length && endMark < listToUse.length) {
var startDist = (listToUse[startMark][0] - range[0][0]).mod(360);
var endDist = (listToUse[endMark][0] - range[1][0]).mod(360);
if (startDist < endDist) {
for (var i = 0; i < listToUse.length; i++) {
removeList.push(i);
}
}
}
removeList.sort(function(a, b){return b-a});
for (var i = 0; i < removeList.length; i++) {
listToUse.splice(removeList[i], 1);
}
if (startBool) {
listToUse.splice(getAngleIndex(listToUse, range[0][0]), 0, range[0]);
}
if (endBool) {
listToUse.splice(getAngleIndex(listToUse, range[1][0]), 0, range[1]);
}
return listToUse;
}
function getAngleRange(blob1, blob2, index) {
var angleStuff = getEdgeLinesFromPoint(blob1, blob2);
var leftAngle = angleStuff[0];
var rightAngle = rangeToAngle(angleStuff);
var difference = angleStuff[1];
drawPoint(angleStuff[2][0], angleStuff[2][1], 3, "");
drawPoint(angleStuff[3][0], angleStuff[3][1], 3, "");
//console.log("Adding badAngles: " + leftAngle + ", " + rightAngle + " diff: " + difference);
var lineLeft = followAngle(leftAngle, blob1.x, blob1.y, 150 + blob1.size - index * 10);
var lineRight = followAngle(rightAngle, blob1.x, blob1.y, 150 + blob1.size - index * 10);
if (blob2.d) {
drawLine(blob1.x, blob1.y, lineLeft[0], lineLeft[1], 6);
drawLine(blob1.x, blob1.y, lineRight[0], lineRight[1], 6);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob1.x, blob1.y, 6);
} else if(getCells().hasOwnProperty(blob2.id)) {
drawLine(blob1.x, blob1.y, lineLeft[0], lineLeft[1], 0);
drawLine(blob1.x, blob1.y, lineRight[0], lineRight[1], 0);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob1.x, blob1.y, 0);
} else {
drawLine(blob1.x, blob1.y, lineLeft[0], lineLeft[1], 3);
drawLine(blob1.x, blob1.y, lineRight[0], lineRight[1], 3);
drawArc(lineLeft[0], lineLeft[1], lineRight[0], lineRight[1], blob1.x, blob1.y, 3);
}
return [leftAngle, difference];
}
//Given a list of conditions, shift the angle to the closest available spot respecting the range given.
function shiftAngle(listToUse, angle, range) {
//TODO: shiftAngle needs to respect the range!
for (var i = 0; i < listToUse.length; i++) {
if (angleIsWithin(angle, listToUse[i])) {
//console.log("Shifting needed!");
var angle1 = listToUse[i][0];
var angle2 = rangeToAngle(listToUse[i]);
var dist1 = (angle - angle1).mod(360);
var dist2 = (angle2 - angle).mod(360);
if (dist1 < dist2) {
return angle1;
} else {
return angle2;
}
}
}
//console.log("No Shifting Was needed!");
return angle;
}
function findDestination(followMouse) {
var player = getPlayer();
var interNodes = getMemoryCells();
if ( /*!toggle*/ 1) {
var useMouseX = (getMouseX() - getWidth() / 2 + getX() * getRatio()) / getRatio();
var useMouseY = (getMouseY() - getHeight() / 2 + getY() * getRatio()) / getRatio();
tempPoint = [useMouseX, useMouseY, 1];
var tempMoveX = getPointX();
var tempMoveY = getPointY();
if (player.length > 0) {
for (var k = 0; k < player.length; k++) {
//console.log("Working on blob: " + k);
drawCircle(player[k].x, player[k].y, player[k].size + splitDistance, 5);
//drawPoint(player[0].x, player[0].y - player[0].size, 3, "" + Math.floor(player[0].x) + ", " + Math.floor(player[0].y));
//var allDots = processEverything(interNodes);
var allPossibleFood = null;
allPossibleFood = getAllFood(player[k]); // #1
var allPossibleThreats = getAllThreats(player[k]);
//console.log("Internodes: " + interNodes.length + " Food: " + allPossibleFood.length + " Threats: " + allPossibleThreats.length);
var allPossibleViruses = getAllViruses(player[k]);
var badAngles = [];
var isSafeSpot = true;
var isMouseSafe = true;
var clusterAllFood = clusterFood(allPossibleFood, player[k].size);
//console.log("Looking for enemies!");
for (var i = 0; i < allPossibleThreats.length; i++) {
var enemyDistance = computeDistance(allPossibleThreats[i].x, allPossibleThreats[i].y, player[k].x, player[k].y);
//console.log("Found distance.");
for (var j = clusterAllFood.length - 1; j >= 0 ; j--) {
var secureDistance = (canSplit(player[k], allPossibleThreats[i]) ? splitDistance : player[k].size*2) + allPossibleThreats[i].size;
if (computeDistance(allPossibleThreats[i].x, allPossibleThreats[i].y, clusterAllFood[j][0], clusterAllFood[j][1]) < secureDistance)
clusterAllFood.splice(j, 1);
}
//console.log("Removed some food.");
if (canSplit(player[k], allPossibleThreats[i])) {
drawCircle(allPossibleThreats[i].x, allPossibleThreats[i].y, allPossibleThreats[i].size + splitDistance, 0);
} else {
drawCircle(allPossibleThreats[i].x, allPossibleThreats[i].y, allPossibleThreats[i].size + player[k].size + player[k].size, 3);
}
if (allPossibleThreats[i].danger && f.getLastUpdate() - allPossibleThreats[i].dangerTimeOut > 1000) {
allPossibleThreats[i].danger = false;
}
if ((canSplit(player[k], allPossibleThreats[i]) && enemyDistance < allPossibleThreats[i].size + splitDistance + player[k].size) || (!canSplit(player[k], allPossibleThreats[i]) && enemyDistance < allPossibleThreats[i].size + player[k].size + player[k].size)) {
allPossibleThreats[i].danger = true;
allPossibleThreats[i].dangerTimeOut = f.getLastUpdate();
}
//console.log("Figured out who was important.");
if ((canSplit(player[k], allPossibleThreats[i]) && enemyDistance < allPossibleThreats[i].size + splitDistance + player[k].size) || (!canSplit(player[k], allPossibleThreats[i]) && enemyDistance < allPossibleThreats[i].size + player[k].size) || allPossibleThreats[i].danger) {
badAngles.push(getAngleRange(player[k], allPossibleThreats[i], i));
//drawPoint(lineLeft[0], lineLeft[1], 0, "Left 0 - " + i);
//drawPoint(lineRight[0], lineRight[1], 0, "Right 1 - " + i);
}
//console.log("Done with enemy: " + i);
}
//console.log("Done looking for enemies!");
var goodAngles = [];
var stupidList = [];
var obstacleList = [];
for (var i = 0; i < allPossibleViruses.length; i++) {
var tempOb = getAngleRange(player[k], allPossibleViruses[i], i);
var angle1 = tempOb[0];
var angle2 = rangeToAngle(tempOb);
drawCircle(allPossibleViruses[i].x, allPossibleViruses[i].y, player[k].size, 6);
obstacleList.push([[angle1, true], [angle2, false]]);
}
if (badAngles.length > 0) {
//NOTE: This is only bandaid wall code. It's not the best way to do it.
stupidList = addWall(stupidList, player[k]);
}
for (var i = 0; i < badAngles.length; i++) {
var angle1 = badAngles[i][0];
var angle2 = rangeToAngle(badAngles[i]);
stupidList.push([[angle1, true], [angle2, false]]);
}
//stupidList.push([[45, true], [135, false]]);
//stupidList.push([[10, true], [200, false]]);
//console.log("Added random noob stuff.");
var sortedInterList = [];
var sortedObList = [];
for (var i = 0; i < stupidList.length; i++) {
//console.log("Adding to sorted: " + stupidList[i][0][0] + ", " + stupidList[i][1][0]);
sortedInterList = addAngle(sortedInterList, stupidList[i]);
if (sortedInterList.length == 0) {
break;
}
}
for (var i = 0; i < obstacleList.length; i++) {
sortedObList = addAngle(sortedObList, obstacleList[i]);
if (sortedObList.length == 0) {
break;
}
}
var offsetI = 0;
var obOffsetI = 1;
if (sortedInterList.length > 0 && sortedInterList[0][1]) {
offsetI = 1;
}
if (sortedObList.length > 0 && sortedObList[0][1]) {
obOffsetI = 0;
}
var goodAngles = [];
var obstacleAngles = [];
for (var i = 0; i < sortedInterList.length; i += 2) {
var angle1 = sortedInterList[(i + offsetI).mod(sortedInterList.length)][0];
var angle2 = sortedInterList[(i + 1 + offsetI).mod(sortedInterList.length)][0];
var diff = (angle2 - angle1).mod(360);
goodAngles.push([angle1, diff]);
}
for (var i = 0; i < sortedObList.length; i += 2) {
var angle1 = sortedObList[(i + obOffsetI).mod(sortedObList.length)][0];
var angle2 = sortedObList[(i + 1 + obOffsetI).mod(sortedObList.length)][0];
var diff = (angle2 - angle1).mod(360);
obstacleAngles.push([angle1, diff]);
}
for (var i = 0; i < goodAngles.length; i++) {
var line1 = followAngle(goodAngles[i][0], player[k].x, player[k].y, 100 + player[k].size);
var line2 = followAngle((goodAngles[i][0] + goodAngles[i][1]).mod(360), player[k].x, player[k].y, 100 + player[k].size);
drawLine(player[k].x, player[k].y, line1[0], line1[1], 1);
drawLine(player[k].x, player[k].y, line2[0], line2[1], 1);
drawArc(line1[0], line1[1], line2[0], line2[1], player[k].x, player[k].y, 1);
//drawPoint(player[0].x, player[0].y, 2, "");
drawPoint(line1[0], line1[1], 0, "" + i + ": 0");
drawPoint(line2[0], line2[1], 0, "" + i + ": 1");
}
for (var i = 0; i < obstacleAngles.length; i++) {
var line1 = followAngle(obstacleAngles[i][0], player[k].x, player[k].y, 50 + player[k].size);
var line2 = followAngle((obstacleAngles[i][0] + obstacleAngles[i][1]).mod(360), player[k].x, player[k].y, 50 + player[k].size);
drawLine(player[k].x, player[k].y, line1[0], line1[1], 6);
drawLine(player[k].x, player[k].y, line2[0], line2[1], 6);
drawArc(line1[0], line1[1], line2[0], line2[1], player[k].x, player[k].y, 6);
//drawPoint(player[0].x, player[0].y, 2, "");
drawPoint(line1[0], line1[1], 0, "" + i + ": 0");
drawPoint(line2[0], line2[1], 0, "" + i + ": 1");
}
if (goodAngles.length > 0) {
var bIndex = goodAngles[0];
var biggest = goodAngles[0][1];
for (var i = 1; i < goodAngles.length; i++) {
var size = goodAngles[i][1];
if (size > biggest) {
biggest = size;
bIndex = goodAngles[i];
}
}
var perfectAngle = (bIndex[0] + bIndex[1] / 2).mod(360);
perfectAngle = shiftAngle(obstacleAngles, perfectAngle, bIndex);
var line1 = followAngle(perfectAngle, player[k].x, player[k].y, 300);
drawLine(player[k].x, player[k].y, line1[0], line1[1], 7);
tempMoveX = line1[0];
tempMoveY = line1[1];
} else if (badAngles.length > 0 && goodAngles == 0) {
//TODO: CODE TO HANDLE WHEN THERE IS NO GOOD ANGLE BUT THERE ARE ENEMIES AROUND!!!!!!!!!!!!!
} else if (clusterAllFood.length > 0) {
for (var i = 0; i < clusterAllFood.length; i++) {
//console.log("mefore: " + clusterAllFood[i][2]);
//This is the cost function. Higher is better.
var clusterAngle = getAngle(clusterAllFood[i][0], clusterAllFood[i][1], player[k].x, player[k].y);
clusterAllFood[i][2] = clusterAllFood[i][2] * 6 - computeDistance(clusterAllFood[i][0], clusterAllFood[i][1], player[k].x, player[k].y);
//console.log("Current Value: " + clusterAllFood[i][2]);
//(goodAngles[bIndex][1] / 2 - (Math.abs(perfectAngle - clusterAngle)));
clusterAllFood[i][3] = clusterAngle;
drawPoint(clusterAllFood[i][0], clusterAllFood[i][1], 1, "");
//console.log("After: " + clusterAllFood[i][2]);
}
var bestFoodI = 0;
var bestFood = clusterAllFood[0][2];
for (var i = 1; i < clusterAllFood.length; i++) {
if (bestFood < clusterAllFood[i][2]) {
bestFood = clusterAllFood[i][2];
bestFoodI = i;
}
}
//console.log("Best Value: " + clusterAllFood[bestFoodI][2]);
var distance = computeDistance(player[k].x, player[k].y, clusterAllFood[bestFoodI][0], clusterAllFood[bestFoodI][1]);
var shiftedAngle = shiftAngle(obstacleAngles, getAngle(clusterAllFood[bestFoodI][0], clusterAllFood[bestFoodI][1], player[k].x, player[k].y), [0, 360]);
var destination = followAngle(shiftedAngle, player[k].x, player[k].y, distance);
tempMoveX = destination[0];
tempMoveY = destination[1];
drawLine(player[k].x, player[k].y, tempMoveX, tempMoveY, 1);
} else {
//If there are no enemies around and no food to eat.
}
drawPoint(tempPoint[0], tempPoint[1], tempPoint[2], "");
//drawPoint(tempPoint[0], tempPoint[1], tempPoint[2], "" + Math.floor(computeDistance(tempPoint[0], tempPoint[1], I, J)));
//drawLine(tempPoint[0], tempPoint[1], player[0].x, player[0].y, 6);
//console.log("Slope: " + slope(tempPoint[0], tempPoint[1], player[0].x, player[0].y) + " Angle: " + getAngle(tempPoint[0], tempPoint[1], player[0].x, player[0].y) + " Side: " + (getAngle(tempPoint[0], tempPoint[1], player[0].x, player[0].y) - 90).mod(360));
tempPoint[2] = 1;
//console.log("Done working on blob: " + i);
}
}
//console.log("MOVING RIGHT NOW!");
//console.log("______Never lied ever in my life.");
return [tempMoveX, tempMoveY];
}
}
function screenToGameX(x) {
return (x - getWidth() / 2) / getRatio() + getX();
}
function screenToGameY(y) {
return (y - getHeight() / 2) / getRatio() + getY();
}
function drawPoint(x_1, y_1, drawColor, text) {
f.drawPoint(x_1, y_1, drawColor, text);
}
function drawArc(x_1, y_1, x_2, y_2, x_3, y_3, drawColor) {
f.drawArc(x_1, y_1, x_2, y_2, x_3, y_3, drawColor);
}
function drawLine(x_1, y_1, x_2, y_2, drawColor) {
f.drawLine(x_1, y_1, x_2, y_2, drawColor);
}
function drawCircle(x_1, y_1, radius, drawColor) {
f.drawCircle(x_1, y_1, radius, drawColor);
}
function screenDistance() {
var temp = f.getScreenDistance();
return temp;
}
function getDarkBool() {
return f.getDarkBool();
}
function getMassBool() {
return f.getMassBool();
}
function getMemoryCells() {
return f.getMemoryCells();
}
function getCellsArray() {
return f.getCellsArray();
}
function getCells() {
return f.getCells();
}
function getPlayer() {
return f.getPlayer();
}
function getWidth() {
return f.getWidth();
}
function getHeight() {
return f.getHeight();
}
function getRatio() {
return f.getRatio();
}
function getOffsetX() {
return f.getOffsetX();
}
function getOffsetY() {
return f.getOffsetY();
}
function getX() {
return f.getX();
}
function getY() {
return f.getY();
}
function getPointX() {
return f.getPointX();
}
function getPointY() {
return f.getPointY();
}
function getMouseX() {
return f.getMouseX();
}
function getMouseY() {
return f.getMouseY();
}
function getUpdate() {
return f.getLastUpdate();
}
})(window, jQuery);