/*jslint node: true */
/*jshint -W061 */
/*global goog, Map, let */
"use strict";

// General requires

var _this = this;

require('google-closure-library');
goog.require('goog.structs.PriorityQueue');
goog.require('goog.structs.QuadTree');

// Import game settings.
const c = require('../../config.json');

// Import utilities.
const util = require('./lib/util');
const ran = require('./lib/random');
const hshg = require('./lib/hshg');
const now = require('performance-now');
const nano = require('nanotimer');

let timer = new nano();

// Let's get a cheaper array removal thing
Array.prototype.remove = index => {
    if (index === _this.length - 1) {
        return _this.pop();
    } else {
        let r = _this[index];
        _this[index] = _this.pop();
        return r;
    }
};

var placedDodecagon = false;

// Define player keys

var keys = ['ttoken1', 'ttoken2jerky', 'treejerky', 'treebacon', 'baconjerkey', 'treedirt', 'bacontreecatjerky', 'vector', 'fishy', ':b:uff:b:ate', 'panda'];

global.fps = "Unknown";
var roomSpeed = c.gameSpeed;

let lastTime = now();
let timestep = 1;

var previousTick = now();

const room = {
    lastCycle: undefined,
    cycleSpeed: 1000 / roomSpeed / 20,
    width: c.WIDTH,
    height: c.HEIGHT,
    setup: c.ROOM_SETUP,
    xgrid: c.X_GRID,
    ygrid: c.Y_GRID,
    gameMode: c.MODE,
    skillBoost: c.SKILL_BOOST,
    scale: {
        square: c.WIDTH * c.HEIGHT / 100000000,
        linear: Math.sqrt(c.WIDTH * c.HEIGHT / 100000000)
    },
    maxFood: c.WIDTH * c.HEIGHT / 100000 * c.FOOD_AMOUNT,
    isInRoom: location => {
        return location.x < 0 || location.x > c.WIDTH || location.y < 0 || location.y > c.HEIGHT ? false : true;
    },
    topPlayerID: -1
};
room.findType = type => {
    let output = [];
    let j = 0;
    let x = 0;
    const lengthrow = room.setup.length;
    //room.setup.forEach(row => {
    for (; x < lengthrow; x++) {
        let i = 0;
        let y = 0;
        const lengthcell = room.setup[x].length;
        //row.forEach(cell => {
        for (; y < lengthcell; y++) {
            if (room.setup[x][y] === type) {
                output.push({ x: (i + 0.5) * room.width / room.xgrid, y: (j + 0.5) * room.height / room.ygrid });
            }
            i++;
        }
        j++;
    }
    room[type] = output;
};
room.findType('nest');
room.findType('norm');
room.findType('bas1');
room.findType('bas2');
room.findType('bas3');
room.findType('bas4');
room.findType('bas5');
room.findType('bas6');
room.findType('roid');
room.findType('rock');
room.nestFoodAmount = 1.5 * Math.sqrt(room.nest.length) / room.xgrid / room.ygrid;
room.random = () => {
    return {
        x: ran.irandom(room.width),
        y: ran.irandom(room.height)
    };
};
room.randomType = type => {
    let selection = room[type][ran.irandom(room[type].length - 1)];
    return {
        x: ran.irandom(0.5 * room.width / room.xgrid) * ran.choose([-1, 1]) + selection.x,
        y: ran.irandom(0.5 * room.height / room.ygrid) * ran.choose([-1, 1]) + selection.y
    };
};
room.gauss = clustering => {
    let output;
    do {
        output = {
            x: ran.gauss(room.width / 2, room.height / clustering),
            y: ran.gauss(room.width / 2, room.height / clustering)
        };
    } while (!room.isInRoom(output));
};
room.gaussInverse = clustering => {
    let output;
    do {
        output = {
            x: ran.gaussInverse(0, room.width, clustering),
            y: ran.gaussInverse(0, room.height, clustering)
        };
    } while (!room.isInRoom(output));
    return output;
};
room.gaussRing = (radius, clustering) => {
    let output;
    do {
        output = ran.gaussRing(room.width * radius, clustering);
        output = {
            x: output.x + room.width / 2,
            y: output.y + room.height / 2
        };
    } while (!room.isInRoom(output));
    return output;
};
room.isIn = (type, location) => {
    if (room.isInRoom(location)) {
        let a = Math.floor(location.y * room.ygrid / room.height);
        let b = Math.floor(location.x * room.xgrid / room.width);
        return type === room.setup[a][b];
    } else {
        return false;
    }
};
room.isInNorm = location => {
    if (room.isInRoom(location)) {
        let a = Math.floor(location.y * room.ygrid / room.height);
        let b = Math.floor(location.x * room.xgrid / room.width);
        let v = room.setup[a][b];
        return v !== 'nest';
    } else {
        return false;
    }
};
room.gaussType = (type, clustering) => {
    let selection = room[type][ran.irandom(room[type].length - 1)];
    let location = {};
    do {
        location = {
            x: ran.gauss(selection.x, room.width / room.xgrid / clustering),
            y: ran.gauss(selection.y, room.height / room.ygrid / clustering)
        };
    } while (!room.isIn(type, location));
    return location;
};
util.log(room.width + ' x ' + room.height + ' room initalized.  Max food: ' + room.maxFood + ', max nest food: ' + room.maxFood * room.nestFoodAmount + '.');

// Define a vector
class Vector {
    constructor(x, y) {
        //Vector constructor.
        this.x = x;
        this.y = y;
    }

    update() {
        this.len = this.length;
        this.dir = this.direction;
    }

    get length() {
        return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
    }

    get direction() {
        return Math.atan2(this.y, this.x);
    }
}
function nullVector(v) {
    v.x = 0;v.y = 0; //this guy's useful
}

// Get class definitions and index them
var Class = (() => {
    let def = require('./lib/definitions'),
        i = 0;
    for (let k in def) {
        if (!def.hasOwnProperty(k)) continue;
        def[k].index = i++;
    }
    return def;
})();

// Define IOs (AI)
function nearest(array, location, test = () => {
    return true;
}) {
    let list = new goog.structs.PriorityQueue();
    let d;
    if (!array.length) {
        return undefined;
    }
    array.forEach(function (instance) {
        d = Math.pow(instance.x - location.x, 2) + Math.pow(instance.y - location.y, 2);
        if (test(instance, d)) {
            list.enqueue(d, instance);
        }
    });
    return list.dequeue();
}
function timeOfImpact(p, v, s) {
    // Requires relative position and velocity to aiming point
    let a = s * s - (v.x * v.x + v.y * v.y);
    let b = p.x * v.x + p.y * v.y;
    let c = p.x * p.x + p.y * p.y;

    let d = b * b + a * c;

    let t = 0;
    if (d >= 0) {
        t = Math.max(0, (b + Math.sqrt(d)) / a);
    }

    return t * 0.9;
}

class IO {
    constructor(body) {
        this.body = body;
        this.acceptsFromTop = true;
    }

    think() {
        return {
            target: null,
            goal: null,
            fire: null,
            main: null,
            alt: null,
            power: null
        };
    }
}
class io_doNothing extends IO {
    constructor(body) {
        super(body);
        this.acceptsFromTop = false;
    }

    think() {
        return {
            goal: {
                x: this.body.x,
                y: this.body.y
            },
            main: false,
            alt: false,
            fire: false
        };
    }
}
class io_moveInCircles extends IO {
    constructor(body) {
        super(body);
        this.acceptsFromTop = false;
        this.timer = ran.irandom(10) + 3;
        this.goal = {
            x: this.body.x + 10 * Math.cos(-this.body.facing),
            y: this.body.y + 10 * Math.sin(-this.body.facing)
        };
    }

    think() {
        if (!this.timer--) {
            this.timer = 10;
            this.goal = {
                x: this.body.x + 10 * Math.cos(-this.body.facing),
                y: this.body.y + 10 * Math.sin(-this.body.facing)
            };
        }
        return { goal: this.goal };
    }
}
class io_listenToPlayer extends IO {
    constructor(b, p) {
        super(b);
        this.player = p;
        this.acceptsFromTop = false;
    }

    // THE PLAYER MUST HAVE A VALID COMMAND AND TARGET OBJECT

    think() {
        let targ = {
            x: this.player.target.x,
            y: this.player.target.y
        };
        if (this.player.command.autospin) {
            let kk = Math.atan2(this.body.control.target.y, this.body.control.target.x) + 0.02;
            targ = {
                x: 100 * Math.cos(kk),
                y: 100 * Math.sin(kk)
            };
        }
        if (this.body.invuln) {
            if (this.player.command.right || this.player.command.left || this.player.command.up || this.player.command.down || this.player.command.lmb) {
                this.body.invuln = false;
            }
        }
        this.body.autoOverride = this.player.command.override;
        return {
            target: targ,
            goal: {
                x: this.body.x + this.player.command.right - this.player.command.left,
                y: this.body.y + this.player.command.down - this.player.command.up
            },
            fire: this.player.command.lmb || this.player.command.autofire,
            main: this.player.command.lmb || this.player.command.autospin || this.player.command.autofire,
            alt: this.player.command.rmb
        };
    }
}
class io_mapTargetToGoal extends IO {
    constructor(b) {
        super(b);
    }

    think(input) {
        if (input.main || input.alt) {
            return {
                goal: {
                    x: input.target.x + this.body.x,
                    y: input.target.y + this.body.y
                },
                power: 1
            };
        }
    }
}
class io_boomerang extends IO {
    constructor(b) {
        super(b);
        this.r = 0;
        this.b = b;
        this.m = b.master;
        this.turnover = false;
        let len = 10 * util.getDistance({ x: 0, y: 0 }, b.master.control.target);
        this.myGoal = {
            x: 3 * b.master.control.target.x + b.master.x,
            y: 3 * b.master.control.target.y + b.master.y
        };
    }
    think(input) {
        if (this.b.range > this.r) this.r = this.b.range;
        let t = 1 - Math.sin(2 * Math.PI * this.b.range / this.r) || 1; //1 - Math.sin(2 * Math.PI * this.b.range / this.r) || 1;
        if (!this.turnover) {
            if (this.r && this.b.range < this.r * 0.5) {
                this.turnover = true;
            }
            return {
                goal: this.myGoal,
                power: t
            };
        } else {
            return {
                goal: {
                    x: this.m.x,
                    y: this.m.y
                },
                power: t
            };
        }
    }
}
class io_goToMasterTarget extends IO {
    constructor(body) {
        super(body);
        this.myGoal = {
            x: body.master.control.target.x + body.master.x,
            y: body.master.control.target.y + body.master.y
        };
        this.countdown = 5;
    }

    think() {
        if (this.countdown) {
            if (util.getDistance(this.body, this.myGoal) < 1) {
                this.countdown--;
            }
            return {
                goal: {
                    x: this.myGoal.x,
                    y: this.myGoal.y
                }
            };
        }
    }
}
class io_canRepel extends IO {
    constructor(b) {
        super(b);
    }

    think(input) {
        if (input.alt && input.target) {
            return {
                target: {
                    x: -input.target.x,
                    y: -input.target.y
                },
                main: true
            };
        }
    }
}
class io_alwaysFire extends IO {
    constructor(body) {
        super(body);
    }

    think() {
        return {
            fire: true
        };
    }
}
class io_targetSelf extends IO {
    constructor(body) {
        super(body);
    }

    think() {
        return {
            main: true,
            target: { x: 0, y: 0 }
        };
    }
}
class io_mapAltToFire extends IO {
    constructor(body) {
        super(body);
    }

    think(input) {
        if (input.alt) {
            return {
                fire: true
            };
        }
    }
}
class io_onlyAcceptInArc extends IO {
    constructor(body) {
        super(body);
    }

    think(input) {
        if (input.target && this.body.firingArc != null) {
            if (Math.abs(util.angleDifference(Math.atan2(input.target.y, input.target.x), this.body.firingArc[0])) >= this.body.firingArc[1]) {
                return {
                    fire: false,
                    alt: false,
                    main: false
                };
            }
        }
    }
}
class io_nearestDifferentMaster extends IO {
    constructor(body) {
        super(body);
        this.targetLock = undefined;
        this.tick = ran.irandom(30);
        this.lead = 0;
        this.validTargets = this.buildList(body.fov);
        this.oldHealth = body.health.display();
    }

    buildList(range) {
        // Establish whom we judge in reference to
        let m = { x: this.body.x, y: this.body.y },
            mm = { x: this.body.master.master.x, y: this.body.master.master.y },
            mostDangerous = 0,
            sqrRange = range * range,
            keepTarget = false;
        // Filter through everybody...
        let out = entities.map(e => {
            // Only look at those within our view, and our parent's view, not dead, not our kind, not a bullet/trap/block etc
            if (e.health.amount > 0) {
                if (!e.invuln) {
                    if (e.alpha > 0.015) {
                        if (e.master.master.team !== this.body.master.master.team) {
                            if (e.master.master.team !== -101) {
                                if (e.type === 'tank' || e.type === 'crasher' || !this.body.aiSettings.shapefriend && e.type === 'food') {
                                    if (Math.abs(e.x - m.x) < range && Math.abs(e.y - m.y) < range) {
                                        if (!this.body.aiSettings.blind || Math.abs(e.x - mm.x) < range && Math.abs(e.y - mm.y) < range) return e;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }).filter(e => {
            return e;
        });

        if (!out.length) return [];

        out = out.map(e => {
            // Only look at those within range and arc (more expensive, so we only do it on the few)
            let yaboi = false;
            if (Math.pow(this.body.x - e.x, 2) + Math.pow(this.body.y - e.y, 2) < sqrRange) {
                if (this.body.firingArc == null || this.body.aiSettings.view360) {
                    yaboi = true;
                } else if (Math.abs(util.angleDifference(util.getDirection(this.body, e), this.body.firingArc[0])) < this.body.firingArc[1]) yaboi = true;
            }
            if (yaboi) {
                mostDangerous = Math.max(e.dangerValue, mostDangerous);
                return e;
            }
        }).filter(e => {
            // Only return the highest tier of danger
            if (e != null) {
                if (this.body.aiSettings.farm || e.dangerValue === mostDangerous) {
                    if (this.targetLock) {
                        if (e.id === this.targetLock.id) keepTarget = true;
                    }
                    return e;
                }
            }
        });
        // Reset target if it's not in there
        if (!keepTarget) this.targetLock = undefined;
        return out;
    }

    think(input) {
        // Override target lock upon other commands
        if (input.main || input.alt || this.body.master.autoOverride) {
            this.targetLock = undefined;return {};
        }
        // Otherwise, consider how fast we can either move to ram it or shoot at a potiential target.
        let tracking = this.body.topSpeed,
            range = this.body.fov;
        // Use whether we have functional guns to decide
        for (let i = 0; i < this.body.guns.length; i++) {
            if (this.body.guns[i].canShoot && !this.body.aiSettings.skynet) {
                let v = this.body.guns[i].getTracking();
                tracking = v.speed;
                range = Math.min(range, v.speed * v.range);
                break;
            }
        }
        // Check if my target's alive
        if (this.targetLock) {
            if (this.targetLock.health.amount <= 0) {
                this.targetLock = undefined;
                this.tick = 100;
            }
        }
        // Think damn hard
        if (this.tick++ > 15 * roomSpeed) {
            this.tick = 0;
            this.validTargets = this.buildList(range);
            // Ditch our old target if it's invalid
            if (this.targetLock && this.validTargets.indexOf(this.targetLock) === -1) {
                this.targetLock = undefined;
            }
            // Lock new target if we still don't have one.
            if (this.targetLock == null && this.validTargets.length) {
                this.targetLock = this.validTargets.length === 1 ? this.validTargets[0] : nearest(this.validTargets, { x: this.body.x, y: this.body.y });
                this.tick = -90;
            }
        }
        // Lock onto whoever's shooting me.
        // let damageRef = (this.body.bond == null) ? this.body : this.body.bond;
        // if (damageRef.collisionArray.length && damageRef.health.display() < this.oldHealth) {
        //     this.oldHealth = damageRef.health.display();
        //     if (this.validTargets.indexOf(damageRef.collisionArray[0]) === -1) {
        //         this.targetLock = (damageRef.collisionArray[0].master.id === -1) ? damageRef.collisionArray[0].source : damageRef.collisionArray[0].master;
        //     }
        // }
        // Consider how fast it's moving and shoot at it
        if (this.targetLock != null) {
            let radial = this.targetLock.velocity;
            let diff = {
                x: this.targetLock.x - this.body.x,
                y: this.targetLock.y - this.body.y
            };
            /// Refresh lead time
            if (this.tick % 4 === 0) {
                this.lead = 0;
                // Find lead time (or don't)
                if (!this.body.aiSettings.chase) {
                    let toi = timeOfImpact(diff, radial, tracking);
                    this.lead = toi;
                }
            }
            // And return our aim
            return {
                target: {
                    x: diff.x + this.lead * radial.x,
                    y: diff.y + this.lead * radial.y
                },
                fire: true,
                main: true
            };
        }
        return {};
    }
}
class io_avoid extends IO {
    constructor(body) {
        super(body);
    }

    think(input) {
        let masterId = this.body.master.id;
        let range = this.body.size * this.body.size * 100;
        this.avoid = nearest(entities, { x: this.body.x, y: this.body.y }, function (test, sqrdst) {
            return test.master.id !== masterId && (test.type === 'bullet' || test.type === 'drone' || test.type === 'swarm' || test.type === 'trap' || test.type === 'block') && sqrdst < range;
        });
        // Aim at that target
        if (this.avoid != null) {
            // Consider how fast it's moving.
            let delt = new Vector(this.body.velocity.x - this.avoid.velocity.x, this.body.velocity.y - this.avoid.velocity.y);
            let diff = new Vector(this.avoid.x - this.body.x, this.avoid.y - this.body.y);
            let comp = (delt.x * diff.x + delt.y * diff.y) / delt.length / diff.length;
            let goal = {};
            if (comp > 0) {
                if (input.goal) {
                    let goalDist = Math.sqrt(range / (input.goal.x * input.goal.x + input.goal.y * input.goal.y));
                    goal = {
                        x: input.goal.x * goalDist - diff.x * comp,
                        y: input.goal.y * goalDist - diff.y * comp
                    };
                } else {
                    goal = {
                        x: -diff.x * comp,
                        y: -diff.y * comp
                    };
                }
                return goal;
            }
        }
    }
}
class io_minion extends IO {
    constructor(body) {
        super(body);
        this.turnwise = 1;
    }

    think(input) {
        if (this.body.aiSettings.reverseDirection && ran.chance(0.005)) {
            this.turnwise = -1 * this.turnwise;
        }
        if (input.target != null && (input.alt || input.main)) {
            let sizeFactor = Math.sqrt(this.body.master.size / this.body.master.SIZE);
            let leash = 60 * sizeFactor;
            let orbit = 120 * sizeFactor;
            let repel = 135 * sizeFactor;
            let goal;
            let power = 1;
            let target = new Vector(input.target.x, input.target.y);
            if (input.alt) {
                // Leash
                if (target.length < leash) {
                    goal = {
                        x: this.body.x + target.x,
                        y: this.body.y + target.y
                    };
                    // Spiral repel
                } else if (target.length < repel) {
                    let dir = -this.turnwise * target.direction + Math.PI / 5;
                    goal = {
                        x: this.body.x + Math.cos(dir),
                        y: this.body.y + Math.sin(dir)
                    };
                    // Free repel
                } else {
                    goal = {
                        x: this.body.x - target.x,
                        y: this.body.y - target.y
                    };
                }
            } else if (input.main) {
                // Orbit point
                let dir = this.turnwise * target.direction + 0.01;
                goal = {
                    x: this.body.x + target.x - orbit * Math.cos(dir),
                    y: this.body.y + target.y - orbit * Math.sin(dir)
                };
                if (Math.abs(target.length - orbit) < this.body.size * 2) {
                    power = 0.7;
                }
            }
            return {
                goal: goal,
                power: power
            };
        }
    }
}
class io_hangOutNearMaster extends IO {
    constructor(body) {
        super(body);
        this.acceptsFromTop = false;
        this.orbit = 30;
        this.currentGoal = { x: this.body.source.x, y: this.body.source.y };
        this.timer = 0;
    }
    think(input) {
        if (this.body.source != this.body) {
            let bound1 = this.orbit * 0.8 + this.body.source.size + this.body.size;
            let bound2 = this.orbit * 1.5 + this.body.source.size + this.body.size;
            let dist = util.getDistance(this.body, this.body.source) + Math.PI / 8;
            let output = {
                target: {
                    x: this.body.velocity.x,
                    y: this.body.velocity.y
                },
                goal: this.currentGoal,
                power: undefined
            };
            // Set a goal
            if (dist > bound2 || this.timer > 30) {
                this.timer = 0;

                let dir = util.getDirection(this.body, this.body.source) + Math.PI * ran.random(0.5);
                let len = ran.randomRange(bound1, bound2);
                let x = this.body.source.x - len * Math.cos(dir);
                let y = this.body.source.y - len * Math.sin(dir);
                this.currentGoal = {
                    x: x,
                    y: y
                };
            }
            if (dist < bound2) {
                output.power = 0.15;
                if (ran.chance(0.3)) {
                    this.timer++;
                }
            }
            return output;
        }
    }
}
class io_spin extends IO {
    constructor(b) {
        super(b);
        this.a = 0;
    }

    think(input) {
        this.a += 0.05;
        let offset = 0;
        if (this.body.bond != null) {
            offset = this.body.bound.angle;
        }
        return {
            target: {
                x: Math.cos(this.a + offset),
                y: Math.sin(this.a + offset)
            },
            main: true
        };
    }
}
class io_fastspin extends IO {
    constructor(b) {
        super(b);
        this.a = 0;
    }

    think(input) {
        this.a += 0.072;
        let offset = 0;
        if (this.body.bond != null) {
            offset = this.body.bound.angle;
        }
        return {
            target: {
                x: Math.cos(this.a + offset),
                y: Math.sin(this.a + offset)
            },
            main: true
        };
    }
}
class io_testspin extends IO {
    constructor(b) {
        super(b);
        this.a = 0;
    }

    think(input) {
        this.a += 0.04;
        let offset = Math.sin(this.a);
        if (this.body.bond != null) {
            offset = this.body.bound.angle;
        }
        return {
            target: {
                x: Math.cos(this.a + offset),
                y: Math.sin(this.a + offset)
            },
            main: true
        };
    }
}
class io_reversespin extends IO {
    constructor(b) {
        super(b);
        this.a = 0;
    }

    think(input) {
        this.a -= 0.05;
        let offset = 0;
        if (this.body.bond != null) {
            offset = this.body.bound.angle;
        }
        return {
            target: {
                x: Math.cos(this.a + offset),
                y: Math.sin(this.a + offset)
            },
            main: true
        };
    }
}
class io_dontTurn extends IO {
    constructor(b) {
        super(b);
    }

    think(input) {
        return {
            target: {
                x: 1,
                y: 0
            },
            main: true
        };
    }
}
class io_fleeAtLowHealth extends IO {
    constructor(b) {
        super(b);
        this.fear = util.clamp(ran.gauss(0.7, 0.15), 0.1, 0.9);
    }

    think(input) {
        if (input.fire && input.target != null && this.body.health.amount < this.body.health.max * this.fear) {
            return {
                goal: {
                    x: this.body.x - input.target.x,
                    y: this.body.y - input.target.y
                }
            };
        }
    }

}

/***** ENTITIES *****/
// Define skills
const skcnv = {
    rld: 0,
    pen: 1,
    str: 2,
    dam: 3,
    spd: 4,

    shi: 5,
    atk: 6,
    hlt: 7,
    rgn: 8,
    mob: 9
};
const levelers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 38, 40, 42, 44];
class Skill {
    constructor(inital = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) {
        // Just skill stuff.
        this.changed = true;
        this.raw = inital;
        this.caps = [];
        this.setCaps([c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL, c.MAX_SKILL]);
        this.name = ['Reload', 'Bullet Penetration', 'Bullet Health', 'Bullet Damage', 'Bullet Speed', 'Shield Capacity', 'Body Damage', 'Max Health', 'Shield Regeneration', 'Movement Speed'];
        this.atk = 0;
        this.hlt = 0;
        this.spd = 0;
        this.str = 0;
        this.pen = 0;
        this.dam = 0;
        this.rld = 0;
        this.mob = 0;
        this.rgn = 0;
        this.shi = 0;
        this.rst = 0;
        this.brst = 0;
        this.ghost = 0;
        this.acl = 0;

        this.reset();
    }

    reset() {
        this.points = 0;
        this.score = 0;
        this.deduction = 0;
        this.level = 0;
        this.canUpgrade = false;
        this.update();
        this.maintain();
    }

    update() {
        let curve = (() => {
            function make(x) {
                return Math.log(4 * x + 1) / Math.log(5);
            }
            let a = [];
            for (let i = 0; i < c.MAX_SKILL * 2; i++) {
                a.push(make(i / c.MAX_SKILL));
            }
            // The actual lookup function
            return x => {
                return a[x * c.MAX_SKILL];
            };
        })();
        function apply(f, x) {
            return x < 0 ? 1 / (1 - x * f) : f * x + 1;
        }
        for (let i = 0; i < 10; i++) {
            if (this.raw[i] > this.caps[i]) {
                this.points += this.raw[i] - this.caps[i];
                this.raw[i] = this.caps[i];
            }
        }
        let attrib = [];
        for (let i = 0; i < 5; i++) {
            for (let j = 0; j < 2; j += 1) {
                attrib[i + 5 * j] = curve((this.raw[i + 5 * j] + this.bleed(i, j)) / c.MAX_SKILL);
            }
        }
        this.rld = Math.pow(0.5, attrib[skcnv.rld]);
        this.pen = apply(2.5, attrib[skcnv.pen]);
        this.str = apply(2, attrib[skcnv.str]);
        this.dam = apply(3, attrib[skcnv.dam]);
        this.spd = (0.5 + apply(1.5, attrib[skcnv.spd])) / 3;

        this.acl = apply(0.5, attrib[skcnv.rld]);

        this.rst = 0.5 * attrib[skcnv.str] + 2.5 * attrib[skcnv.pen];
        this.ghost = attrib[skcnv.pen];

        this.shi = c.GLASS_HEALTH_FACTOR * apply(3 / c.GLASS_HEALTH_FACTOR - 1, attrib[skcnv.shi]);
        this.atk = apply(1, attrib[skcnv.atk]);
        this.hlt = c.GLASS_HEALTH_FACTOR * apply(2 / c.GLASS_HEALTH_FACTOR - 1, attrib[skcnv.hlt]);
        this.mob = apply(0.8, attrib[skcnv.mob]);
        this.rgn = apply(25, attrib[skcnv.rgn]);

        this.brst = 0.3 * (0.5 * attrib[skcnv.atk] + 0.5 * attrib[skcnv.hlt] + attrib[skcnv.rgn]);
        this.changed = true;
    }

    set(thing) {
        this.raw[0] = thing[0];
        this.raw[1] = thing[1];
        this.raw[2] = thing[2];
        this.raw[3] = thing[3];
        this.raw[4] = thing[4];
        this.raw[5] = thing[5];
        this.raw[6] = thing[6];
        this.raw[7] = thing[7];
        this.raw[8] = thing[8];
        this.raw[9] = thing[9];
        this.update();
    }

    setCaps(thing) {
        this.caps[0] = thing[0];
        this.caps[1] = thing[1];
        this.caps[2] = thing[2];
        this.caps[3] = thing[3];
        this.caps[4] = thing[4];
        this.caps[5] = thing[5];
        this.caps[6] = thing[6];
        this.caps[7] = thing[7];
        this.caps[8] = thing[8];
        this.caps[9] = thing[9];
        this.update();
    }

    maintain() {
        if (this.level < c.SKILL_CAP) {
            if (this.score - this.deduction >= this.levelScore) {
                this.deduction += this.levelScore;
                this.level += 1;
                this.points += this.levelPoints;
                if (this.level == c.TIER_1 || this.level == c.TIER_2 || this.level == c.TIER_3) {
                    this.canUpgrade = true;
                }
                this.update();
                return true;
            }
        }
        return false;
    }

    get levelScore() {
        return Math.ceil(1.8 * Math.pow(this.level + 1, 1.8) - 2 * this.level + 1);
    }

    get progress() {
        return this.levelScore ? (this.score - this.deduction) / this.levelScore : 0;
    }

    get levelPoints() {
        if (levelers.findIndex(e => {
            return e === this.level;
        }) != -1) {
            return 1;
        }return 0;
    }

    cap(skill, real = false) {
        if (!real && this.level < c.SKILL_SOFT_CAP) {
            return Math.round(this.caps[skcnv[skill]] * c.SOFT_MAX_SKILL);
        }
        return this.caps[skcnv[skill]];
    }

    bleed(i, j) {
        let a = (i + 2) % 5 + 5 * j,
            b = (i + (j === 1 ? 1 : 4)) % 5 + 5 * j;
        let value = 0;
        let denom = Math.max(c.MAX_SKILL, this.caps[i + 5 * j]);
        value += (1 - Math.pow(this.raw[a] / denom - 1, 2)) * this.raw[a] * c.SKILL_LEAK;
        value -= Math.pow(this.raw[b] / denom, 2) * this.raw[b] * c.SKILL_LEAK;

        return value;
    }

    upgrade(stat) {
        if (this.points && this.amount(stat) < this.cap(stat)) {
            this.change(stat, 1);
            this.points -= 1;
            return true;
        }
        return false;
    }

    title(stat) {
        return this.name[skcnv[stat]];
    }

    /*
    let i = skcnv[skill] % 5,
        j = (skcnv[skill] - i) / 5;
    let roundvalue = Math.round(this.bleed(i, j) * 10);
    let string = '';
    if (roundvalue > 0) { string += '+' + roundvalue + '%'; }
    if (roundvalue < 0) { string += '-' + roundvalue + '%'; }
     return string;
    */

    amount(skill) {
        return this.raw[skcnv[skill]];
    }

    change(skill, levels) {
        this.raw[skcnv[skill]] += levels;
        this.update();
    }
}

const lazyRealSizes = (() => {
    let o = [1, 1, 1];
    for (var i = 3; i < 16; i++) {
        // We say that the real size of a 0-gon, 1-gon, 2-gon is one, then push the real sizes of triangles, squares, etc...
        o.push(Math.sqrt(2 * Math.PI / i * (1 / Math.sin(2 * Math.PI / i))));
    }
    return o;
})();

// Define how guns work
class Gun {
    constructor(body, info) {
        this.lastShot = {
            time: 0,
            power: 0
        };
        this.body = body;
        this.master = body.source;
        this.label = '';
        this.controllers = [];
        this.children = [];
        this.control = {
            target: new Vector(0, 0),
            goal: new Vector(0, 0),
            main: false,
            alt: false,
            fire: false
        };
        this.poisoned = false;
        this.poison = false;
        this.poisonedBy = -1;
        this.poisonLevel = 0;
        this.poisonToApply = 0;
        this.showpoison = false;
        this.poisonTimer = 0;
        this.canShoot = false;
        if (info.PROPERTIES != null && info.PROPERTIES.TYPE != null) {
            this.canShoot = true;
            this.label = info.PROPERTIES.LABEL == null ? '' : info.PROPERTIES.LABEL;
            if (Array.isArray(info.PROPERTIES.TYPE)) {
                // This is to be nicer about our definitions
                this.bulletTypes = info.PROPERTIES.TYPE;
                this.natural = info.PROPERTIES.TYPE.BODY;
            } else {
                this.bulletTypes = [info.PROPERTIES.TYPE];
            }
            // Pre-load bullet definitions so we don't have to recalculate them every shot
            let natural = {};
            function setNatural(type) {
                if (type.PARENT != null) {
                    // Make sure we load from the parents first
                    for (let i = 0; i < type.PARENT.length; i++) {
                        setNatural(type.PARENT[i]);
                    }
                }
                if (type.BODY != null) {
                    // Get values if they exist
                    for (let index in type.BODY) {
                        natural[index] = type.BODY[index];
                    }
                }
            }
            let z = 0;
            const length = this.bulletTypes.length;
            for (; z < length; z++) {
                setNatural(this.bulletTypes[z]);
            }
            this.natural = natural; // Save it
            if (info.PROPERTIES.GUN_CONTROLLERS != null) {
                let toAdd = [];
                let self = this;
                //info.PROPERTIES.GUN_CONTROLLERS.forEach(function(ioName) {
                //    toAdd.push(eval('new ' + ioName + '(self)'));
                //});
                let i = 0;
                const length = info.PROPERTIES_GUN_CONTROLLERS.length;
                for (; i < length; i++) {
                    toAdd.push(eval('new ' + info.PROPERTIES.GUN_CONTROLLERS[i] + '(self)'));
                }
                this.controllers = toAdd.concat(this.controllers);
            }
            this.autofire = info.PROPERTIES.AUTOFIRE == null ? false : info.PROPERTIES.AUTOFIRE;
            this.altFire = info.PROPERTIES.ALT_FIRE == null ? false : info.PROPERTIES.ALT_FIRE;
            this.settings = info.PROPERTIES.SHOOT_SETTINGS == null ? [] : info.PROPERTIES.SHOOT_SETTINGS;
            this.calculator = info.PROPERTIES.STAT_CALCULATOR == null ? 'default' : info.PROPERTIES.STAT_CALCULATOR;
            this.waitToCycle = info.PROPERTIES.WAIT_TO_CYCLE == null ? false : info.PROPERTIES.WAIT_TO_CYCLE;
            this.bulletStats = info.PROPERTIES.BULLET_STATS == null || info.PROPERTIES.BULLET_STATS == 'master' ? 'master' : new Skill(info.PROPERTIES.BULLET_STATS);
            this.settings = info.PROPERTIES.SHOOT_SETTINGS == null ? [] : info.PROPERTIES.SHOOT_SETTINGS;
            this.countsOwnKids = info.PROPERTIES.MAX_CHILDREN == null ? false : info.PROPERTIES.MAX_CHILDREN;
            this.syncsSkills = info.PROPERTIES.SYNCS_SKILLS == null ? false : info.PROPERTIES.SYNCS_SKILLS;
            this.negRecoil = info.PROPERTIES.NEGATIVE_RECOIL == null ? false : info.PROPERTIES.NEGATIVE_RECOIL;
        }
        let position = info.POSITION;
        this.length = position[0] / 10;
        this.width = position[1] / 10;
        this.aspect = position[2];
        let _off = new Vector(position[3], position[4]);
        this.angle = position[5] * Math.PI / 180;
        this.direction = _off.direction;
        this.offset = _off.length / 10;
        this.delay = position[6];

        this.position = 0;
        this.motion = 0;
        if (this.canShoot) {
            this.cycle = !this.waitToCycle - this.delay;
            this.trueRecoil = this.settings.recoil * 1.675;
        }
    }

    recoil() {
        if (this.motion || this.position) {
            // Simulate recoil
            this.motion -= 0.25 * this.position / roomSpeed;
            this.position += this.motion;
            if (this.position < 0) {
                // Bouncing off the back
                this.position = 0;
                this.motion = -this.motion;
            }
            if (this.motion > 0) {
                this.motion *= 0.75;
            }
        }
        if (this.canShoot && !this.body.settings.hasNoRecoil) {
            // Apply recoil to motion
            if (this.motion > 0) {
                let recoilForce = -this.position * this.trueRecoil * 0.045 / roomSpeed;
                this.body.accel.x += recoilForce * Math.cos(this.body.facing + this.angle);
                this.body.accel.y += recoilForce * Math.sin(this.body.facing + this.angle);
            }
        }
    }

    getSkillRaw() {
        if (this.bulletStats === 'master') {
            return [this.body.skill.raw[0], this.body.skill.raw[1], this.body.skill.raw[2], this.body.skill.raw[3], this.body.skill.raw[4], 0, 0, 0, 0, 0];
        }
        return this.bulletStats.raw;
    }

    getLastShot() {
        return this.lastShot;
    }

    live() {
        // Do
        this.recoil();
        // Dummies ignore this
        if (this.canShoot) {
            // Find the proper skillset for shooting
            let sk = this.bulletStats === 'master' ? this.body.skill : this.bulletStats;
            // Decides what to do based on child-counting settings
            let shootPermission = this.countsOwnKids ? this.countsOwnKids > this.children.length * (this.calculator == 'necro' ? sk.rld : 1) : this.body.maxChildren ? this.body.maxChildren > this.body.children.length * (this.calculator == 'necro' ? sk.rld : 1) : true;
            // Override in invuln
            if (this.body.master.invuln) {
                shootPermission = false;
            }
            // Cycle up if we should
            if (shootPermission || !this.waitToCycle) {
                if (this.cycle < 1) {
                    this.cycle += 1 / (this.settings.reload * 2) / roomSpeed / (this.calculator == 'necro' || this.calculator == 'fixed reload' ? 1 : sk.rld);
                }
            }
            // Firing routines
            if (shootPermission && (this.autofire || (this.altFire ? this.body.control.alt : this.body.control.fire))) {
                if (this.cycle >= 1) {
                    // Find the end of the gun barrel
                    let gx = this.offset * Math.cos(this.direction + this.angle + this.body.facing) + (1.5 * this.length - this.width * this.settings.size / 2) * Math.cos(this.angle + this.body.facing);
                    let gy = this.offset * Math.sin(this.direction + this.angle + this.body.facing) + (1.5 * this.length - this.width * this.settings.size / 2) * Math.sin(this.angle + this.body.facing);
                    // Shoot, multiple times in a tick if needed
                    while (shootPermission && this.cycle >= 1) {
                        this.fire(gx, gy, sk);
                        // Figure out if we may still shoot
                        shootPermission = this.countsOwnKids ? this.countsOwnKids > this.children.length : this.body.maxChildren ? this.body.maxChildren > this.body.children.length : true;
                        // Cycle down
                        this.cycle -= 1;
                    }
                } // If we're not shooting, only cycle up to where we'll have the proper firing delay
            } else if (this.cycle > !this.waitToCycle - this.delay) {
                this.cycle = !this.waitToCycle - this.delay;
            }
        }
    }

    syncChildren() {
        if (this.syncsSkills) {
            let self = this;
            let i = 0;
            const length = this.children.length;
            for (; i < length; i++) {
                //for (let instance of this.children) {
                let instance = this.children[i];
                instance.define({
                    BODY: self.interpret(),
                    SKILL: self.getSkillRaw()
                });
                instance.refreshBodyAttributes();
            }
        }
    }

    fire(gx, gy, sk) {
        // Recoil
        this.lastShot.time = util.time();
        this.lastShot.power = 3 * Math.log(Math.sqrt(sk.spd) + this.trueRecoil + 1) + 1;
        this.motion += this.lastShot.power;
        // Find inaccuracy
        let ss, sd;
        do {
            ss = ran.gauss(0, Math.sqrt(this.settings.shudder));
        } while (Math.abs(ss) >= this.settings.shudder * 2);
        do {
            sd = ran.gauss(0, this.settings.spray * this.settings.shudder);
        } while (Math.abs(sd) >= this.settings.spray / 2);
        sd *= Math.PI / 180;
        // Find speed
        let s = new Vector((this.negRecoil ? -1 : 1) * this.settings.speed * c.runSpeed * sk.spd * (1 + ss) * Math.cos(this.angle + this.body.facing + sd), (this.negRecoil ? -1 : 1) * this.settings.speed * c.runSpeed * sk.spd * (1 + ss) * Math.sin(this.angle + this.body.facing + sd));
        // Boost it if we should
        if (this.body.velocity.length) {
            let extraBoost = Math.max(0, s.x * this.body.velocity.x + s.y * this.body.velocity.y) / this.body.velocity.length / s.length;
            if (extraBoost) {
                let len = s.length;
                s.x += this.body.velocity.length * extraBoost * s.x / len;
                s.y += this.body.velocity.length * extraBoost * s.y / len;
            }
        }
        // Create the bullet
        /*
        var o = new Entity({
            x: this.body.x + this.body.size * gx - s.x,
            y: this.body.y + this.body.size * gy - s.y,
        }, this.master.master);
        let jumpAhead = this.cycle - 1;
        if (jumpAhead) {
            o.x += s.x * this.cycle / jumpAhead;
            o.y += s.y * this.cycle / jumpAhead;
        }
        o.velocity = s;
        this.bulletInit(o);
        o.coreSize = o.SIZE;
        */
        let o = new Entity({
            x: this.body.x + this.body.size * gx - s.x,
            y: this.body.y + this.body.size * gy - s.y
        }, this.master.master);
        this.bulletInit(o);
        o.x = this.body.x + this.body.size * gx - s.x;
        o.y = this.body.y + this.body.size * gy - s.y;
        o.coreSize = o.SIZE;
        o.velocity = s;
    }

    bulletInit(o) {
        // Define it by its natural properties
        //this.bulletTypes.forEach(type => o.define(type));
        const length = this.bulletTypes.length;
        let i = 0;
        for (; i < length; i++) {
            o.define(this.bulletTypes[i]);
        }
        // Pass the gun attributes
        o.define({
            BODY: this.interpret(),
            SKILL: this.getSkillRaw(),
            SIZE: this.body.size * this.width * this.settings.size / 2,
            LABEL: this.master.label + (this.label ? ' ' + this.label : '') + ' ' + o.label
        });
        o.color = this.body.master.color;
        // Keep track of it and give it the function it needs to deutil.log itself upon death
        if (this.countsOwnKids) {
            o.parent = this;
            this.children.push(o);
        } else if (this.body.maxChildren) {
            o.parent = this.body;
            this.body.children.push(o);
            this.children.push(o);
        }
        o.source = this.body;
        o.facing = o.velocity.direction;
        // Necromancers.
        if (this.calculator == 'necro') {
            let oo = o;
            o.necro = host => {
                let shootPermission = this.countsOwnKids ? this.countsOwnKids > this.children.length * (this.bulletStats === 'master' ? this.body.skill.rld : this.bulletStats.rld) : this.body.maxChildren ? this.body.maxChildren > this.body.children.length * (this.bulletStats === 'master' ? this.body.skill.rld : this.bulletStats.rld) : true;
                if (shootPermission) {
                    let save = {
                        facing: host.facing,
                        size: host.SIZE
                    };
                    host.define(Class.genericEntity);
                    this.bulletInit(host);
                    host.team = oo.master.master.team;
                    host.master = oo.master;
                    host.color = oo.color;
                    host.facing = save.facing;
                    host.SIZE = save.size;
                    host.health.amount = host.health.max;
                    return true;
                }
                return false;
            };
        }
        // Otherwise
        o.refreshBodyAttributes();
        o.life();
    }

    getTracking() {
        return {
            speed: c.runSpeed * (this.bulletStats == 'master' ? this.body.skill.spd : this.bulletStats.spd) * this.settings.maxSpeed * this.natural.SPEED,
            range: Math.sqrt(this.bulletStats == 'master' ? this.body.skill.spd : this.bulletStats.spd) * this.settings.range * this.natural.RANGE
        };
    }

    interpret() {
        let sizeFactor = this.master.size / this.master.SIZE;
        let shoot = this.settings;
        let sk = this.bulletStats == 'master' ? this.body.skill : this.bulletStats;
        // Defaults
        let out = {
            SPEED: shoot.maxSpeed * sk.spd,
            HEALTH: shoot.health * sk.str,
            RESIST: shoot.resist + sk.rst,
            DAMAGE: shoot.damage * sk.dam,
            PENETRATION: Math.max(1, shoot.pen * sk.pen),
            RANGE: shoot.range / Math.sqrt(sk.spd),
            DENSITY: shoot.density * sk.pen * sk.pen / sizeFactor,
            PUSHABILITY: 1 / sk.pen,
            HETERO: 3 - 2.8 * sk.ghost
        };
        // Special cases
        switch (this.calculator) {
            case 'thruster':
                this.trueRecoil = this.settings.recoil * Math.sqrt(sk.rld * sk.spd);
                break;
            case 'sustained':
                out.RANGE = shoot.range;
                break;
            case 'swarm':
                out.PENETRATION = Math.max(1, shoot.pen * (0.5 * (sk.pen - 1) + 1));
                out.HEALTH /= shoot.pen * sk.pen;
                break;
            case 'trap':
            case 'block':
                out.PUSHABILITY = 1 / Math.pow(sk.pen, 0.5);
                out.RANGE = shoot.range;
                break;
            case 'necro':
            case 'drone':
                out.PUSHABILITY = 1;
                out.PENETRATION = Math.max(1, shoot.pen * (0.5 * (sk.pen - 1) + 1));
                out.HEALTH = (shoot.health * sk.str + sizeFactor) / Math.pow(sk.pen, 0.8);
                out.DAMAGE = shoot.damage * sk.dam * Math.sqrt(sizeFactor) * shoot.pen * sk.pen;
                out.RANGE = shoot.range * Math.sqrt(sizeFactor);
                break;
        }
        // Go through and make sure we respect its natural properties
        for (let property in out) {
            if (this.natural[property] == null || !out.hasOwnProperty(property)) continue;
            out[property] *= this.natural[property];
        }
        return out;
    }
}
// Define entities
var minimap = [];
var views = [];
var entitiesToAvoid = [];
const dirtyCheck = (p, r) => {
    return entitiesToAvoid.some(e => {
        return Math.abs(p.x - e.x) < r + e.size && Math.abs(p.y - e.y) < r + e.size;
    });
};
const grid = new hshg.HSHG();
var entitiesIdLog = 0;
var entities = [];
const purgeEntities = () => {
    entities = entities.filter(e => {
        return !e.isGhost;
    });
};

var bringToLife = (() => {
    let remapTarget = (i, ref, self) => {
        if (i.target == null || !i.main && !i.alt) return undefined;
        return {
            x: i.target.x + ref.x - self.x,
            y: i.target.y + ref.y - self.y
        };
    };
    let passer = (a, b, acceptsFromTop) => {
        return index => {
            if (a != null && a[index] != null && (b[index] == null || acceptsFromTop)) {
                b[index] = a[index];
            }
        };
    };
    return my => {
        // Size
        if (my.SIZE !== my.coreSize) my.coreSize = my.SIZE;
        // Think
        let faucet = my.settings.independent || my.source == null || my.source === my ? {} : my.source.control;
        let b = {
            target: remapTarget(faucet, my.source, my),
            goal: undefined,
            fire: faucet.fire,
            main: faucet.main,
            alt: faucet.alt,
            power: undefined
        };
        // Seek attention
        if (my.settings.attentionCraver && !faucet.main && my.range) {
            my.range -= 1;
        }
        // So we start with my master's thoughts and then we filter them down through our control stack
        for (let AI of my.controllers) {
            let a = AI.think(b);
            let passValue = passer(a, b, AI.acceptsFromTop);
            passValue('target');
            passValue('goal');
            passValue('fire');
            passValue('main');
            passValue('alt');
            passValue('power');
        }
        my.control.target = b.target == null ? my.control.target : b.target;
        my.control.goal = b.goal;
        my.control.fire = b.fire;
        my.control.main = b.main;
        my.control.alt = b.alt;
        my.control.power = b.power == null ? 1 : b.power;
        // React
        my.move();
        my.face();
        // Handle guns and turrets if we've got them
        for (let gun of my.guns) {
            gun.live();
        }
        for (let turret of my.turrets) {
            turret.life();
        }
        if (my.skill.maintain()) my.refreshBodyAttributes();
        //if (my.invisible[1]) {
        //    my.alpha = Math.max(0.01, my.alpha - my.invisible[1]);
        //    if (!(my.velocity.x * my.velocity.x + my.velocity.y * my.velocity.y < 0.15 * 0.15) || my.damageRecieved)
        //      	my.alpha = Math.min(1, my.alpha + my.invisible[0]);
        //} else my.alpha = 1;
    };
})();

class HealthType {
    constructor(health, type, resist = 0) {
        this.max = health;
        this.amount = health;
        this.type = type;
        this.resist = resist;
        this.regen = 0;
    }

    set(health, regen = 0) {
        this.amount = this.max ? this.amount / this.max * health : health;
        this.max = health;
        this.regen = regen;
    }

    display() {
        return this.amount / this.max;
    }

    getDamage(amount, capped = true) {
        switch (this.type) {
            case 'dynamic':
                return capped ? Math.min(amount * this.permeability, this.amount) : amount * this.permeability;
            case 'static':
                return capped ? Math.min(amount, this.amount) : amount;
        }
    }

    regenerate(boost = false) {
        boost /= 2;
        let cons = 5;
        switch (this.type) {
            case 'static':
                if (this.amount >= this.max || !this.amount) break;
                this.amount += cons * (this.max / 10 / 60 / 2.5 + boost);
                break;
            case 'dynamic':
                let r = util.clamp(this.amount / this.max, 0, 1);
                if (!r) {
                    this.amount = 0.0001;
                }
                if (r === 1) {
                    this.amount = this.max;
                } else {
                    this.amount += cons * (this.regen * Math.exp(-50 * Math.pow(Math.sqrt(0.5 * r) - 0.4, 2)) / 3 + r * this.max / 10 / 15 + boost);
                }
                break;
        }
        this.amount = util.clamp(this.amount, 0, this.max);
    }

    get permeability() {
        switch (this.type) {
            case 'static':
                return 1;
            case 'dynamic':
                return this.max ? util.clamp(this.amount / this.max, 0, 1) : 0;
        }
    }

    get ratio() {
        return this.max ? util.clamp(1 - Math.pow(this.amount / this.max - 1, 4), 0, 1) : 0;
    }
}

class Entity {
    constructor(position, master = this) {
        this.cache = [0, 0, 0, 0, 0, 0];
        this.defaultset = false;
        this.isGhost = false;
        this.killCount = { solo: 0, assists: 0, bosses: 0, killers: [] };
        this.creationTime = new Date().getTime();
        // Inheritance
        this.master = master;
        this.source = this;
        this.parent = this;
        this.control = {
            target: new Vector(0, 0),
            goal: new Vector(0, 0),
            main: false,
            alt: false,
            fire: false,
            power: 0
        };
        this.isInGrid = false;
        this.removeFromGrid = () => {
            if (this.isInGrid) {
                grid.removeObject(this);this.isInGrid = false;
            }
        };
        this.addToGrid = () => {
            if (!this.isInGrid && this.bond == null) {
                grid.addObject(this);this.isInGrid = true;
            }
        };

        this.activation = (() => {
            let active = true;
            let timer = ran.irandom(15);
            return {
                update: () => {
                    if (this.triggerFunctions.UPDATE != null) {
                        this.triggerFunctions.UPDATE(this);
                    }
                    if (this.isDead()) return 0;
                    // Check if I'm in anybody's view
                    if (!active) {
                        this.removeFromGrid();
                        // Remove bullets and swarm
                        if (this.settings.diesAtRange) this.kill();
                        // Still have limited update cycles but do it much more slowly.
                        if (!timer--) active = true;
                    } else {
                        this.addToGrid();
                        timer = 15;
                        active = views.some(v => v.check(this, 0.6));
                    }
                },
                check: () => {
                    return active;
                }
            };
        })();
        this.autoOverride = false;
        this.controllers = [];
        this.blend = {
            color: '#FFFFFF',
            amount: 0
        };
        // Objects
        this.skill = new Skill();
        this.health = new HealthType(1, 'static', 0);
        this.shield = new HealthType(0, 'dynamic');
        this.guns = [];
        this.turrets = [];
        this.upgrades = [];
        this.settings = {};
        this.aiSettings = {};
        this.children = [];
        // Define it
        this.SIZE = 1;
        this.define(Class.genericEntity);
        // Initalize physics and collision
        this.facing = 0;
        this.vfacing = 0;
        this.range = 0;
        this.damageRecieved = 0;
        this.stepRemaining = 1;
        this.collisionArray = [];
        this.invuln = false;
        this.alpha = 1;
        // Physics 2.0 stuff
        this.x = position.x;
        this.y = position.y;
        this.velocity = new Vector(0, 0);
        this.accel = new Vector(0, 0);
        this.impulse = new Vector(0, 0);
        this.maxSpeed = 0;
        this.maxAccel = 0;
        this.resistance = 0.13;
        this.impulseZero = 0.01;
        this.knockbackLimit = 125;
        // Get a new unique id
        this.id = entitiesIdLog++;
        this.team = this.id;
        this.team = master.team;
        // This is for collisions
        this.updateAABB = () => {};
        this.getAABB = (() => {
            let data = {},
                savedSize = 0;
            let getLongestEdge = (x1, y1, x2, y2) => {
                return Math.max(Math.abs(x2 - x1), Math.abs(y2 - y1));
            };
            this.updateAABB = active => {
                if (this.bond != null) return 0;
                if (!active) {
                    data.active = false;return 0;
                }
                // Get bounds
                let x1 = Math.min(this.x, this.x + this.velocity.x + this.accel.x) - this.realSize - 5;
                let y1 = Math.min(this.y, this.y + this.velocity.y + this.accel.y) - this.realSize - 5;
                let x2 = Math.max(this.x, this.x + this.velocity.x + this.accel.x) + this.realSize + 5;
                let y2 = Math.max(this.y, this.y + this.velocity.y + this.accel.y) + this.realSize + 5;
                // Size check
                let size = getLongestEdge(x1, y1, x2, y1);
                let sizeDiff = savedSize / size;
                // Update data
                data = {
                    min: [x1, y1],
                    max: [x2, y2],
                    active: true,
                    size: size
                };
                // Update grid if needed
                if (sizeDiff > Math.SQRT2 || sizeDiff < Math.SQRT1_2) {
                    this.removeFromGrid();this.addToGrid();
                    savedSize = data.size;
                }
            };
            return () => {
                return data;
            };
        })();
        this.updateAABB(true);
        // note, these dont have to be defined but having them as null
        // can make things more obvious to what trigger functions actually exist
        this.triggerFunctions = {
            UPDATE: myself => null, // takes in parameter (myself) which will be the entity its being called on
            DEATH: myself => null // this takes in parameter (myself) which is the entity its called on, all thats information is good enough for us not needing other parameters
        };
        entities.push(this); // everything else
        //views.forEach(v => v.add(this));
        let i = 0;
        const length = views.length;
        for (; i < length; i++) {
            views[i].add(this);
        }
    }

    life() {
        bringToLife(this);
    }

    addController(newIO) {
        if (Array.isArray(newIO)) {
            this.controllers = newIO.concat(this.controllers);
        } else {
            this.controllers.unshift(newIO);
        }
    }

    define(set, mockupDefine = false) {
        if (set.PARENT != null) {
            for (let i = 0; i < set.PARENT.length; i++) {
                this.define(set.PARENT[i]);
            }
        }
        if (set.index != null) {
            this.index = set.index;
        }
        if (set.NAME != null) {
            this.name = set.NAME;
        }
        if (set.LABEL != null) {
            this.label = set.LABEL;
        }
        if (set.TYPE != null) {
            this.type = set.TYPE;
        }
        if (set.SHAPE != null) {
            this.shape = typeof set.SHAPE === 'number' ? set.SHAPE : 0;
            this.shapeData = set.SHAPE;
        }
        /*
        if (set.CUSTOMSHAPE != null && set.CUSTOMSHAPE.length > 0) {
           this.customshape = set.CUSTOMSHAPE;
           console.log(this.customshape);
        }
        */
        if (set.COLOR != null) {
            this.color = set.COLOR;
        }
        if (set.CONTROLLERS != null) {
            let toAdd = [];
            //set.CONTROLLERS.forEach((ioName) => {
            //    toAdd.push(eval('new io_' + ioName + '(this)'));
            //});
            let i = 0;
            const length = set.CONTROLLERS.length;
            for (; i < length; i++) {
                toAdd.push(eval('new io_' + set.CONTROLLERS[i] + '(this)'));
            }
            this.addController(toAdd);
        }
        if (set.POISON != null) {
            this.poison = set.POISON;
        }
        if (set.POISONED != null) {
            this.poisoned = set.POISONED;
        }
        if (set.POISON_TO_APPLY != null) {
            this.poisonToApply = set.POISON_TO_APPLY;
        }
        if (set.SHOWPOISON != null) {
            this.showpoison = set.SHOWPOISON;
        }
        if (set.MOTION_TYPE != null) {
            this.motionType = set.MOTION_TYPE;
        }
        if (set.FACING_TYPE != null) {
            this.facingType = set.FACING_TYPE;
        }
        if (set.DRAW_HEALTH != null) {
            this.settings.drawHealth = set.DRAW_HEALTH;
        }
        if (set.DRAW_SELF != null) {
            this.settings.drawShape = set.DRAW_SELF;
        }
        if (set.DAMAGE_EFFECTS != null) {
            this.settings.damageEffects = set.DAMAGE_EFFECTS;
        }
        if (set.RATIO_EFFECTS != null) {
            this.settings.ratioEffects = set.RATIO_EFFECTS;
        }
        if (set.MOTION_EFFECTS != null) {
            this.settings.motionEffects = set.MOTION_EFFECTS;
        }
        if (set.ACCEPTS_SCORE != null) {
            this.settings.acceptsScore = set.ACCEPTS_SCORE;
        }
        if (set.GIVE_KILL_MESSAGE != null) {
            this.settings.givesKillMessage = set.GIVE_KILL_MESSAGE;
        }
        if (set.CAN_GO_OUTSIDE_ROOM != null) {
            this.settings.canGoOutsideRoom = set.CAN_GO_OUTSIDE_ROOM;
        }
        if (set.HITS_OWN_TYPE != null) {
            this.settings.hitsOwnType = set.HITS_OWN_TYPE;
        }
        if (set.DIE_AT_LOW_SPEED != null) {
            this.settings.diesAtLowSpeed = set.DIE_AT_LOW_SPEED;
        }
        if (set.DIE_AT_RANGE != null) {
            this.settings.diesAtRange = set.DIE_AT_RANGE;
        }
        if (set.INDEPENDENT != null) {
            this.settings.independent = set.INDEPENDENT;
        }
        if (set.PERSISTS_AFTER_DEATH != null) {
            this.settings.persistsAfterDeath = set.PERSISTS_AFTER_DEATH;
        }
        if (set.CLEAR_ON_MASTER_UPGRADE != null) {
            this.settings.clearOnMasterUpgrade = set.CLEAR_ON_MASTER_UPGRADE;
        }
        if (set.HEALTH_WITH_LEVEL != null) {
            this.settings.healthWithLevel = set.HEALTH_WITH_LEVEL;
        }
        if (set.ACCEPTS_SCORE != null) {
            this.settings.acceptsScore = set.ACCEPTS_SCORE;
        }
        if (set.OBSTACLE != null) {
            this.settings.obstacle = set.OBSTACLE;
        }
        if (set.NECRO != null) {
            this.settings.isNecromancer = set.NECRO;
        }
        if (set.AUTO_UPGRADE != null) {
            this.settings.upgrading = set.AUTO_UPGRADE;
        }
        if (set.HAS_NO_RECOIL != null) {
            this.settings.hasNoRecoil = set.HAS_NO_RECOIL;
        }
        if (set.CRAVES_ATTENTION != null) {
            this.settings.attentionCraver = set.CRAVES_ATTENTION;
        }
        if (set.BROADCAST_MESSAGE != null) {
            this.settings.broadcastMessage = set.BROADCAST_MESSAGE === '' ? undefined : set.BROADCAST_MESSAGE;
        }
        if (set.DAMAGE_CLASS != null) {
            this.settings.damageClass = set.DAMAGE_CLASS;
        }
        if (set.BUFF_VS_FOOD != null) {
            this.settings.buffVsFood = set.BUFF_VS_FOOD;
        }
        if (set.CAN_BE_ON_LEADERBOARD != null) {
            this.settings.leaderboardable = set.CAN_BE_ON_LEADERBOARD;
        }
        if (set.INTANGIBLE != null) {
            this.intangibility = set.INTANGIBLE;
        }
        if (set.IS_SMASHER != null) {
            this.settings.reloadToAcceleration = set.IS_SMASHER;
        }
        if (set.STAT_NAMES != null) {
            this.settings.skillNames = set.STAT_NAMES;
        }
        if (set.AI != null) {
            this.aiSettings = set.AI;
        }
        if (set.DANGER != null) {
            this.dangerValue = set.DANGER;
        }
        if (set.VARIES_IN_SIZE != null) {
            this.settings.variesInSize = set.VARIES_IN_SIZE;
            this.squiggle = this.settings.variesInSize ? ran.randomRange(0.8, 1.2) : 1;
        }
        if (set.RESET_UPGRADES) {
            this.upgrades = [];
        }
        if (set.ALPHA != null) this.alpha = set.ALPHA;
        if (set.INVISIBLE != null) this.invisible = [set.INVISIBLE[0], set.INVISIBLE[1]];
        if (set.UPGRADES_TIER_1 != null) {
            //set.UPGRADES_TIER_1.forEach((e) => {
            //    this.upgrades.push({class: e, level: c.TIER_1, index: e.index});
            //});
            let i = 0;
            const length = set.UPGRADES_TIER_1.length;
            for (; i < length; i++) {
                this.upgrades.push({ class: set.UPGRADES_TIER_1[i], level: c.TIER_1, index: set.UPGRADES_TIER_1[i].index });
            }
        }
        if (set.UPGRADES_TIER_2 != null) {
            //set.UPGRADES_TIER_2.forEach((e) => {
            //    this.upgrades.push({class: e, level: c.TIER_2, index: e.index});
            //});
            let i = 0;
            const length = set.UPGRADES_TIER_2.length;
            for (; i < length; i++) {
                this.upgrades.push({ class: set.UPGRADES_TIER_2[i], level: c.TIER_2, index: set.UPGRADES_TIER_2[i].index });
            }
        }
        if (set.UPGRADES_TIER_3 != null) {
            //set.UPGRADES_TIER_3.forEach((e) => {
            //    this.upgrades.push({class: e, level: c.TIER_3, index: e.index});
            //});
            let i = 0;
            const length = set.UPGRADES_TIER_3.length;
            for (; i < length; i++) {
                this.upgrades.push({ class: set.UPGRADES_TIER_3[i], level: c.TIER_3, index: set.UPGRADES_TIER_3[i].index });
            }
        }
        if (set.SIZE != null) {
            this.SIZE = set.SIZE * this.squiggle;
            if (this.coreSize == null) {
                this.coreSize = this.SIZE;
            }
        }
        if (set.SKILL != null && set.SKILL != []) {
            if (set.SKILL.length != 10) {
                throw 'Inappropiate skill raws.';
            }
            this.skill.set(set.SKILL);
        }
        if (set.LEVEL != null) {
            if (set.LEVEL === -1) {
                this.skill.reset();
            }
            while (this.skill.level < c.SKILL_CHEAT_CAP && this.skill.level < set.LEVEL) {
                this.skill.score += this.skill.levelScore;
                this.skill.maintain();
            }
            this.refreshBodyAttributes();
        }
        if (set.SKILL_CAP != null && set.SKILL_CAP != []) {
            if (set.SKILL_CAP.length != 10) {
                throw 'Inappropiate skill caps.';
            }
            this.skill.setCaps(set.SKILL_CAP);
        }
        if (set.VALUE != null) {
            this.skill.score = Math.max(this.skill.score, set.VALUE * this.squiggle);
        }
        if (set.ALT_ABILITIES != null) {
            this.abilities = set.ALT_ABILITIES;
        }
        if (set.GUNS != null) {
            let newGuns = [];
            //set.GUNS.forEach((gundef) => {
            //    newGuns.push(new Gun(this, gundef));
            //});
            let i = 0;
            const length = set.GUNS.length;
            for (; i < length; i++) {
                newGuns.push(new Gun(this, set.GUNS[i]));
            }
            this.guns = newGuns;
        }
        if (set.MAX_CHILDREN != null) {
            this.maxChildren = set.MAX_CHILDREN;
        }
        if (set.FOOD != null) {
            if (set.FOOD.LEVEL != null) {
                this.foodLevel = set.FOOD.LEVEL;
                this.foodCountup = 0;
            }
        }
        if (set.BODY != null) {
            if (set.BODY.ACCELERATION != null) {
                this.ACCELERATION = set.BODY.ACCELERATION;
            }
            if (set.BODY.SPEED != null) {
                this.SPEED = set.BODY.SPEED;
            }
            if (set.BODY.HEALTH != null) {
                this.HEALTH = set.BODY.HEALTH;
            }
            if (set.BODY.RESIST != null) {
                this.RESIST = set.BODY.RESIST;
            }
            if (set.BODY.SHIELD != null) {
                this.SHIELD = set.BODY.SHIELD;
            }
            if (set.BODY.REGEN != null) {
                this.REGEN = set.BODY.REGEN;
            }
            if (set.BODY.DAMAGE != null) {
                this.DAMAGE = set.BODY.DAMAGE;
            }
            if (set.BODY.PENETRATION != null) {
                this.PENETRATION = set.BODY.PENETRATION;
            }
            if (set.BODY.FOV != null) {
                this.FOV = set.BODY.FOV;
            }
            if (set.BODY.RANGE != null) {
                this.RANGE = set.BODY.RANGE;
            }
            if (set.BODY.SHOCK_ABSORB != null) {
                this.SHOCK_ABSORB = set.BODY.SHOCK_ABSORB;
            }
            if (set.BODY.DENSITY != null) {
                this.DENSITY = set.BODY.DENSITY;
            }
            if (set.BODY.STEALTH != null) {
                this.STEALTH = set.BODY.STEALTH;
            }
            if (set.BODY.PUSHABILITY != null) {
                this.PUSHABILITY = set.BODY.PUSHABILITY;
            }
            if (set.BODY.HETERO != null) {
                this.heteroMultiplier = set.BODY.HETERO;
            }
            this.refreshBodyAttributes();
        }
        if (set.TURRETS != null) {
            let o;
            let i = 0;
            let j = 0;
            const lengthi = this.turrets.length;
            const lengthj = set.TURRETS.length;
            //this.turrets.forEach(o => o.destroy());
            for (; i < lengthi; i++) {
                this.turrets[i].destroy();
            }
            this.turrets = [];
            for (; j < lengthj; j++) {
                let def = set.TURRETS[j];
                o = new Entity(this, this.master);
                (Array.isArray(def.TYPE) ? def.TYPE : [def.TYPE]).forEach(type => o.define(type));
                o.bindToMaster(def.POSITION, this);
            }
        }
        if (set.TRIGGERS != null && mockupDefine === false) {
            let entries = Object.entries(set.TRIGGERS);
            for (let i = 0; i < entries.length; i++) {
                let entry = entries[i];
                if (typeof entry[1] === 'function') {
                    if (this.triggerFunctions[entry[0]] != null) {
                        this.triggerFunctions[entry[0]] = entry[1];
                    } else {
                        util.error('Unknown trigger function ' + entry[0] + ' being defined by definition ' + set.LABEL);
                    }
                } else {
                    util.error('Trigger function ' + entry[0] + ' being defined by definition ' + set.LABEL + ' is not a function!');
                }
                // so if i had update or something thats setup,
                // now i can call that if i have a place for it like
                // inside the objects activation update the update trigger
                // function is called if its actually defined,
                // you could also split up update into two triggers,
                // AlwaysUpdate to always update even when the object died and
                // Update for when it isnt dead, though right now updates set to when
                // it isnt dead. anyway lets go to exports.explosion in definitions
                // to see these things in action!
            }
        }
        if (set.mockup != null) {
            this.mockup = set.mockup;
        }
    }

    refreshBodyAttributes() {
        if (this.cache === undefined) {
            this.cache = [0, 0, 0, 0, 0, 0];
        }

        if (this.defaultset === false || this.skill.changed === true) {
            let speedReduce = Math.pow(this.size / (this.coreSize || this.SIZE), 1);

            this.acceleration = c.runSpeed * this.ACCELERATION / speedReduce;
            if (this.settings.reloadToAcceleration) this.acceleration *= this.skill.acl;
            this.cache[0] = this.ACCELERATION;

            this.topSpeed = c.runSpeed * this.SPEED * this.skill.mob / speedReduce * 2.58853046592;
            if (this.settings.reloadToAcceleration) this.topSpeed /= Math.sqrt(this.skill.acl);
            this.cache[1] = this.SPEED;

            this.health.set(((this.settings.healthWithLevel ? 2 * this.skill.level : 0) + this.HEALTH) * this.skill.hlt);

            this.health.resist = 1 - 1 / Math.max(1, this.RESIST + this.skill.brst);

            this.shield.set(((this.settings.healthWithLevel ? 0.6 * this.skill.level : 0) + this.SHIELD) * this.skill.shi, Math.max(0, ((this.settings.healthWithLevel ? 0.006 * this.skill.level : 0) + 1) * this.REGEN * this.skill.rgn));

            this.damage = this.DAMAGE * this.skill.atk;

            this.penetration = this.PENETRATION + 1.5 * (this.skill.brst + 0.8 * (this.skill.atk - 1));

            if (!this.settings.dieAtRange || !this.range) {
                this.range = this.RANGE;
            }

            if (this.size < 12) {
                this.fov = this.FOV * 400 * Math.sqrt(1 / (0.1 * this.size)) * (0.9 + 0.0001 * (this.size / 4));
            } else {
                this.fov = this.FOV * 400 * Math.sqrt(1 * (0.2 * this.size)) * (0.9 + 0.0001 * (this.size / 4));
            }

            this.density = (1 + 0.08 * this.skill.level) * this.DENSITY;

            this.stealth = this.STEALTH;

            this.pushability = this.PUSHABILITY;

            this.defaultset = true;
            this.skill.changed = false;
        }

        /*
        let speedReduce = Math.pow(this.size / (this.coreSize || this.SIZE), 1);

        if (this.ACCELERATION != this.cache[0]) {
        this.acceleration = c.runSpeed * this.ACCELERATION / speedReduce;
        if (this.settings.reloadToAcceleration) this.acceleration *= this.skill.acl;
        this.cache[0] = this.ACCELERATION;
        }

        if (this.SPEED != this.cache[1]) {
        this.topSpeed = (c.runSpeed * this.SPEED * this.skill.mob / speedReduce) * 1.14866039425;
        if (this.settings.reloadToAcceleration) this.topSpeed /= Math.sqrt(this.skill.acl);
        this.cache[1] = this.SPEED;
        }
        */

        /*
        if (this.HEALTH != this.cache[2]) {
        this.health.set(
            (((this.settings.healthWithLevel) ? 2 * this.skill.level : 0) + this.HEALTH) * this.skill.hlt
        );
        this.health.resist = 1 - 1 / Math.max(1, this.RESIST + this.skill.brst);
        this.cache[2] = this.HEALTH;
        }
         if (this.SHIELD != this.cache[3]) {
        this.shield.set(
            (((this.settings.healthWithLevel) ? 0.6 * this.skill.level : 0) + this.SHIELD) * this.skill.shi,
            Math.max(0, ((((this.settings.healthWithLevel) ? 0.006 * this.skill.level : 0) + 1) * this.REGEN) * this.skill.rgn)
        );
        this.cache[3] = this.SHIELD;
        }

        if (this.skill.atk != this.cache[4]) {
        this.damage = this.DAMAGE * this.skill.atk;
        this.cache[4] = this.skill.atk;
        }

        if (this.skill.brst != this.cache[5]) {
        this.penetration = this.PENETRATION + 1.5 * (this.skill.brst + 0.8 * (this.skill.atk - 1));
        this.cache[5] = this.skill.brst;
        }
         if (!this.settings.dieAtRange || !this.range) {
            this.range = this.RANGE;
        }

        this.fov = this.FOV * 250 * Math.sqrt(this.size) * (1 + 0.003 * this.skill.level);

        this.density = (1 + 0.08 * this.skill.level) * this.DENSITY;

        this.stealth = this.STEALTH;
         this.pushability = this.PUSHABILITY;
        */
    }

    bindToMaster(position, bond) {
        this.bond = bond;
        this.source = bond;
        this.bond.turrets.push(this);
        this.skill = this.bond.skill;
        this.label = this.bond.label + ' ' + this.label;
        // It will not be in collision calculations any more nor shall it be seen.
        this.removeFromGrid();
        this.settings.drawShape = false;
        // Get my position.
        this.bound = {};
        this.bound.size = position[0] / 20;
        let _off = new Vector(position[1], position[2]);
        this.bound.angle = position[3] * Math.PI / 180;
        this.bound.direction = _off.direction;
        this.bound.offset = _off.length / 10;
        this.bound.arc = position[4] * Math.PI / 180;
        // Figure out how we'll be drawn.
        this.bound.layer = position[5];
        // Initalize.
        this.facing = this.bond.facing + this.bound.angle;
        this.facingType = 'bound';
        this.motionType = 'bound';
        this.move();
    }

    get size() {
        if (this.bond == null) return (this.coreSize || this.SIZE) * (1 + this.skill.level / 45);
        return this.bond.size * this.bound.size;
    }

    get mass() {
        return this.density * (this.size * this.size + 1);
    }

    get realSize() {
        if (Array.isArray(this.shape)) {
            return this.size * (Math.abs(1) > lazyRealSizes.length ? 1 : lazyRealSizes[Math.abs(1)]);
        } else {
            return this.size * (Math.abs(this.shape) > lazyRealSizes.length ? 1 : lazyRealSizes[Math.abs(this.shape)]);
        }
    }

    get m_x() {
        return (this.velocity.x + this.accel.x) / roomSpeed;
    }
    get m_y() {
        return (this.velocity.y + this.accel.y) / roomSpeed;
    }

    camera(tur = false) {
        return {
            type: 0 + tur * 0x01 + this.settings.drawHealth * 0x02 + (this.type === 'tank') * 0x04,
            id: this.id,
            index: this.index,
            x: this.x,
            y: this.y,
            vx: this.velocity.x,
            vy: this.velocity.y,
            size: this.size,
            rsize: this.realSize,
            status: 1,
            health: this.health.display(),
            shield: this.shield.display(),
            facing: this.facing,
            vfacing: this.vfacing,
            twiggle: this.facingType === 'autospin' || this.facingType === 'locksFacing' && this.control.alt,
            layer: this.bond != null ? this.bound.layer : this.type === 'wall' ? 11 : this.type === 'food' ? 10 : this.type === 'tank' ? 5 : this.type === 'crasher' ? 1 : 0,
            color: this.color,
            name: this.name,
            score: this.skill.score,
            guns: this.guns.map(gun => gun.getLastShot()),
            turrets: this.turrets.map(turret => turret.camera(true)),
            alpha: this.alpha
        };
    }

    skillUp(stat) {
        let suc = this.skill.upgrade(stat);
        if (suc) {
            this.refreshBodyAttributes();
            //this.guns.forEach(function(gun) {
            //    gun.syncChildren();
            //});
            let i = 0;
            const length = this.guns.length;
            for (; i < length; i++) {
                this.guns[i].syncChildren();
            }
        }
        return suc;
    }

    upgrade(number) {
        if (number < this.upgrades.length && this.skill.level >= this.upgrades[number].level) {
            let saveMe = this.upgrades[number].class;
            this.upgrades = [];
            this.define(saveMe);
            this.sendMessage('You have upgraded to ' + this.label + '.');
            let ID = this.id;
            //entities.forEach(instance => {
            //    if (instance.settings.clearOnMasterUpgrade && instance.master.id === ID) {
            //        instance.kill();
            //    }
            //});
            let i = 0;
            const length = entities.length;
            for (; i < length; i++) {
                if (entities[i].settings.clearOnMasterUpgrade && entities[i].master.id === ID) {
                    entities[i].kill();
                }
            }
            this.skill.update();
            this.skill.changed = true;
            this.refreshBodyAttributes();
        }
    }

    damageMultiplier() {
        switch (this.type) {
            case 'swarm':
                return 0.25 + 1.5 * util.clamp(this.range / (this.RANGE + 1), 0, 1);
            default:
                return 1;
        }
    }

    move() {
        let g = {
            x: this.control.goal.x - this.x,
            y: this.control.goal.y - this.y
        },
            gactive = g.x !== 0 || g.y !== 0,
            engine = {
            x: 0,
            y: 0
        },
            a = this.acceleration / roomSpeed;
        switch (this.motionType) {
            case 'glide':
                this.maxSpeed = this.topSpeed;
                this.damp = 0.05;
                break;
            case 'motor':
                this.maxSpeed = 0;
                if (this.topSpeed) {
                    this.damp = a / this.topSpeed;
                }
                if (gactive) {
                    let len = Math.sqrt(g.x * g.x + g.y * g.y);
                    engine = {
                        x: a * g.x / len,
                        y: a * g.y / len
                    };
                }
                break;
            case 'swarm':
                this.maxSpeed = this.topSpeed;
                let l = util.getDistance({ x: 0, y: 0 }, g) + 1;
                if (gactive && l > this.size) {
                    let desiredxspeed = this.topSpeed * g.x / l,
                        desiredyspeed = this.topSpeed * g.y / l,
                        turning = Math.sqrt((this.topSpeed * Math.max(1, this.range) + 1) / a);
                    engine = {
                        x: (desiredxspeed - this.velocity.x) / Math.max(5, turning) * 1.2145,
                        y: (desiredyspeed - this.velocity.y) / Math.max(5, turning) * 1.2145
                    };
                } else {
                    if (this.velocity.length < this.topSpeed) {
                        engine = {
                            x: this.velocity.x * a / 40,
                            y: this.velocity.y * a / 40
                        };
                    }
                }
                break;
            case 'chase':
                if (gactive) {
                    let l = util.getDistance({ x: 0, y: 0 }, g);
                    if (l > this.size * 2) {
                        this.maxSpeed = this.topSpeed;
                        let desiredxspeed = this.topSpeed * g.x / l,
                            desiredyspeed = this.topSpeed * g.y / l;
                        engine = {
                            x: (desiredxspeed - this.velocity.x) * a,
                            y: (desiredyspeed - this.velocity.y) * a
                        };
                    } else {
                        this.maxSpeed = 0;
                    }
                } else {
                    this.maxSpeed = 0;
                }
                break;
            case 'drift':
                this.maxSpeed = 0;
                engine = {
                    x: g.x * a,
                    y: g.y * a
                };
                break;
            case 'bound':
                let bound = this.bound,
                    ref = this.bond;
                this.x = ref.x + ref.size * bound.offset * Math.cos(bound.direction + bound.angle + ref.facing);
                this.y = ref.y + ref.size * bound.offset * Math.sin(bound.direction + bound.angle + ref.facing);
                this.bond.velocity.x += bound.size * this.accel.x;
                this.bond.velocity.y += bound.size * this.accel.y;
                this.firingArc = [ref.facing + bound.angle, bound.arc / 2];
                nullVector(this.accel);
                this.blend = ref.blend;
                break;
        }
        this.accel.x += engine.x * this.control.power;
        this.accel.y += engine.y * this.control.power;
    }

    face() {
        let t = this.control.target,
            tactive = t.x !== 0 || t.y !== 0,
            oldFacing = this.facing;
        switch (this.facingType) {
            case 'autospin':
                this.facing += 0.02 / roomSpeed;
                break;
            case 'turnWithSpeed':
                this.facing += this.velocity.length / 90 * Math.PI / roomSpeed;
                break;
            case 'withMotion':
                this.facing = this.velocity.direction;
                break;
            case 'smoothWithMotion':
            case 'looseWithMotion':
                this.facing += util.loopSmooth(this.facing, this.velocity.direction, 4 / roomSpeed);
                break;
            case 'withTarget':
            case 'toTarget':
                this.facing = Math.atan2(t.y, t.x);
                break;
            case 'locksFacing':
                if (!this.control.alt) this.facing = Math.atan2(t.y, t.x);
                break;
            case 'looseWithTarget':
            case 'looseToTarget':
            case 'smoothToTarget':
                this.facing += util.loopSmooth(this.facing, Math.atan2(t.y, t.x), 1 / roomSpeed);
                break;
            case 'bound':
                let givenangle;
                if (this.control.main) {
                    givenangle = Math.atan2(t.y, t.x);
                    let diff = util.angleDifference(givenangle, this.firingArc[0]);
                    if (Math.abs(diff) >= this.firingArc[1]) {
                        givenangle = this.firingArc[0]; // - util.clamp(Math.sign(diff), -this.firingArc[1], this.firingArc[1]);
                    }
                } else {
                    givenangle = this.firingArc[0];
                }
                this.facing += util.loopSmooth(this.facing, givenangle, 4 / roomSpeed);
                break;
        }
        // Loop
        while (this.facing < 0) {
            this.facing += 2 * Math.PI;
        }
        while (this.facing > 2 * Math.PI) {
            this.facing -= 2 * Math.PI;
        }
        this.vfacing = util.angleDifference(oldFacing, this.facing) * roomSpeed;
    }

    takeSelfie() {
        this.flattenedPhoto = null;
        this.photo = this.settings.drawShape ? this.camera() : this.photo = undefined;
    }

    physics() {
        if (this.accel.x == null || this.velocity.x == null) {
            util.error('Void Error!');
            util.error(this.collisionArray);
            util.error(this.label);
            util.error(this);
            nullVector(this.accel);nullVector(this.velocity);
        }
        // Apply acceleration
        this.velocity.x += this.accel.x * timestep;
        this.velocity.y += this.accel.y * timestep;
        // Reset acceleration
        //if (!this.accel <= 0) {
        nullVector(this.accel);
        //}
        // Apply motion
        this.stepRemaining = 1;
        this.x += this.stepRemaining * this.velocity.x / roomSpeed;
        this.y += this.stepRemaining * this.velocity.y / roomSpeed;
    }

    friction() {
        var motion = this.velocity.length,
            excess = motion - this.maxSpeed;
        if (excess > 0 && this.damp) {
            var k = this.damp * timestep * 0.97,
                drag = excess / (k + 1),
                finalVelocity = this.maxSpeed + drag;
            this.velocity.x = finalVelocity * this.velocity.x / motion * 0.97;
            this.velocity.y = finalVelocity * this.velocity.y / motion * 0.97;
        }
    }

    confinementToTheseEarthlyShackles() {
        if (this.x == null || this.x == null) {
            util.error('Void Error!');
            util.error(this.collisionArray);
            util.error(this.label);
            util.error(this);
            nullVector(this.accel);nullVector(this.velocity);
            return 0;
        }
        if (!this.settings.canGoOutsideRoom) {
            this.accel.x -= Math.min(this.x - this.realSize + 50, 0) * c.ROOM_BOUND_FORCE / roomSpeed; //roomSpeed for next 3
            this.accel.x -= Math.max(this.x + this.realSize - room.width - 50, 0) * c.ROOM_BOUND_FORCE / roomSpeed;
            this.accel.y -= Math.min(this.y - this.realSize + 50, 0) * c.ROOM_BOUND_FORCE / roomSpeed;
            this.accel.y -= Math.max(this.y + this.realSize - room.height - 50, 0) * c.ROOM_BOUND_FORCE / roomSpeed;
        }
        if (room.gameMode === 'tdm' && this.type !== 'food') {
            let loc = { x: this.x, y: this.y };
            if (this.team !== -1 && room.isIn('bas1', loc) || this.team !== -2 && room.isIn('bas2', loc) || this.team !== -3 && room.isIn('bas3', loc) || this.team !== -4 && room.isIn('bas4', loc) || this.team !== -5 && room.isIn('bas5', loc) || this.team !== -6 && room.isIn('bas6', loc)) {
                this.kill();
            }
        }
    }

    contemplationOfMortality() {
        if (this.invuln) {
            this.damageRecieved = 0;
            return 0;
        }
        // Life-limiting effects
        if (this.settings.diesAtRange) {
            this.range -= 1 / roomSpeed;
            if (this.range < 0) {
                this.kill();
            }
        }
        if (this.settings.diesAtLowSpeed) {
            if (!this.collisionArray.length && this.velocity.length < this.topSpeed / 2) {
                this.health.amount -= this.health.getDamage(1 / roomSpeed);
            }
        }
        // Shield regen and damage
        if (this.shield.max) {
            if (this.damageRecieved !== 0) {
                let shieldDamage = this.shield.getDamage(this.damageRecieved);
                this.damageRecieved -= shieldDamage;
                this.shield.amount -= shieldDamage;
            }
        }
        // Health damage
        if (this.damageRecieved !== 0) {
            let healthDamage = this.health.getDamage(this.damageRecieved);
            this.blend.amount = 1;
            this.health.amount -= healthDamage;
        }
        this.damageRecieved = 0;

        // Check for death
        if (this.isDead()) {
            // Initalize message arrays
            let killers = [],
                killTools = [],
                notJustFood = false;
            // If I'm a tank, call me a nameless player
            let name = this.master.name == '' ? this.master.type === 'tank' ? "a nameless player's " + this.label : this.master.type === 'miniboss' ? "a visiting " + this.label : util.addArticle(this.label) : this.master.name + "'s " + this.label;
            // Calculate the jackpot
            let jackpot = Math.ceil(util.getJackpot(this.skill.score) / this.collisionArray.length);
            // Now for each of the things that kill me...
            /*
            this.collisionArray.forEach(instance => {
                if (instance.type === 'wall') return 0;
                if (instance.master.settings.acceptsScore) { // If it's not food, give its master the score
                    if (instance.master.type === 'tank' || instance.master.type === 'miniboss') notJustFood = true;
                    instance.master.skill.score += jackpot;
                    killers.push(instance.master); // And keep track of who killed me
                } else if (instance.settings.acceptsScore) {
                    instance.skill.score += jackpot;
                }
                killTools.push(instance); // Keep track of what actually killed me
            });
            */

            let i = 0;
            const length = this.collisionArray.length;
            for (; i < length; i++) {
                //for (let instance of this.collisionArray) {
                let instance = this.collisionArray[i];
                if (instance.type === 'wall') return 0;
                if (instance.master.settings.acceptsScore) {
                    // If it's not food, give its master the score
                    if (instance.master.type === 'tank' || instance.master.type === 'miniboss') notJustFood = true;
                    instance.master.skill.score += jackpot;
                    killers.push(instance.master); // And keep track of who killed me
                } else if (instance.settings.acceptsScore) {
                    instance.skill.score += jackpot;
                }
                killTools.push(instance); // Keep track of what actually killed me
            }
            // Remove duplicates
            killers = killers.filter((elem, index, self) => {
                return index == self.indexOf(elem);
            });
            // If there's no valid killers (you were killed by food), change the message to be more passive
            let killText = notJustFood ? '' : "You have been killed by ",
                dothISendAText = this.settings.givesKillMessage;
            killers.forEach(instance => {
                this.killCount.killers.push(instance.index);
                if (this.type === 'tank') {
                    if (killers.length > 1) instance.killCount.assists++;else instance.killCount.solo++;
                } else if (this.type === "miniboss") instance.killCount.bosses++;
            });
            // Add the killers to our death message, also send them a message
            if (notJustFood) {
                killers.forEach(instance => {
                    if (instance.master.type !== 'food' && instance.master.type !== 'crasher') {
                        killText += instance.name == '' ? killText == '' ? 'An unnamed player' : 'an unnamed player' : instance.name;
                        killText += ' and ';
                    }
                    // Only if we give messages
                    if (dothISendAText) {
                        instance.sendMessage('You killed ' + name + (killers.length > 1 ? ' (with some help).' : '.'));
                    }
                });
                // Prepare the next part of the next
                killText = killText.slice(0, -4);
                killText += 'killed you with ';
            }
            // Broadcast
            if (this.settings.broadcastMessage) sockets.broadcast(this.settings.broadcastMessage);
            // Add the implements to the message
            killTools.forEach(instance => {
                killText += util.addArticle(instance.label) + ' and ';
            });
            // Prepare it and clear the collision array.
            killText = killText.slice(0, -5);
            if (killText === 'You have been kille') killText = 'You have died a stupid death';
            this.sendMessage(killText + '.');
            // If I'm the leader, broadcast it:
            if (this.id === room.topPlayerID) {
                let usurptText = this.name === '' ? 'The leader' : this.name;
                if (notJustFood) {
                    usurptText += ' has been usurped by';
                    killers.forEach(instance => {
                        usurptText += ' ';
                        usurptText += instance.name === '' ? 'an unnamed player' : instance.name;
                        usurptText += ' and';
                    });
                    usurptText = usurptText.slice(0, -4);
                    usurptText += '!';
                } else {
                    usurptText += ' fought a polygon... and the polygon won.';
                }
                sockets.broadcast(usurptText);
            }
            // Kill it
            return 1;
        }
        return 0;
    }

    protect() {
        entitiesToAvoid.push(this);this.isProtected = true;
    }

    sendMessage(message) {} // Dummy

    kill() {
        this.health.amount = -1;
    }

    spawn(...args) {
        let e = new Entity(...args);
        return e;
    }

    destroy() {
        if (this.triggerFunctions.DEATH != null) {
            this.triggerFunctions.DEATH(this);
        }
        // Remove from the protected entities list
        if (this.isProtected) util.remove(entitiesToAvoid, entitiesToAvoid.indexOf(this));
        // Remove from minimap
        let i = minimap.findIndex(entry => {
            return entry[0] === this.id;
        });
        if (i != -1) util.remove(minimap, i);
        // Remove this from views
        //views.forEach(v => v.remove(this));
        let v = 0;
        const length = views.length;
        for (; v < length; v++) {
            views[v].remove(this);
        }
        // Remove from parent lists if needed
        if (this.parent != null) util.remove(this.parent.children, this.parent.children.indexOf(this));
        // Kill all of its children
        let ID = this.id;
        let instance = entities.find(o => o.source.id === this.id);
        if (instance !== undefined) {
            if (instance.source.id === this.id) {
                if (instance.settings.persistsAfterDeath) {
                    instance.source = instance;
                } else {
                    instance.kill();
                }
            }
            if (instance.parent && instance.parent.id === this.id) {
                instance.parent = null;
            }
            if (instance.master.id === this.id) {
                instance.kill();
                instance.master = instance;
            }
        }
        // Remove everything bound to it
        if (this.turrets.length > 0) {
            for (let t of this.turrets) {
                t.destroy();
            }
        }
        // Remove from the collision grid
        this.removeFromGrid();
        this.isGhost = true;
    }

    isDead() {
        return this.health.amount <= 0;
    }
}

/*** SERVER SETUP ***/
// Make a speed monitor
var logs = (() => {
    let logger = (() => {
        // The two basic functions
        function set(obj) {
            obj.time = util.time();
        }
        function mark(obj) {
            obj.data.push(util.time() - obj.time);
        }
        function record(obj) {
            let o = util.averageArray(obj.data);
            obj.data = [];
            return o;
        }
        function sum(obj) {
            let o = util.sumArray(obj.data);
            obj.data = [];
            return o;
        }
        function tally(obj) {
            obj.count++;
        }
        function count(obj) {
            let o = obj.count;
            obj.count = 0;
            return o;
        }
        // Return the logger creator
        return () => {
            let internal = {
                data: [],
                time: util.time(),
                count: 0
            };
            // Return the new logger
            return {
                set: () => set(internal),
                mark: () => mark(internal),
                record: () => record(internal),
                sum: () => sum(internal),
                count: () => count(internal),
                tally: () => tally(internal)
            };
        };
    })();
    // Return our loggers
    return {
        entities: logger(),
        collide: logger(),
        network: logger(),
        minimap: logger(),
        misc2: logger(),
        misc3: logger(),
        physics: logger(),
        life: logger(),
        selfie: logger(),
        master: logger(),
        activation: logger(),
        loops: logger()
    };
})();

// Essential server requires
var express = require('express'),
    http = require('http'),
    url = require('url'),
    WebSocket = require('ws'),
    app = express(),
    fs = require('fs'),
    exportDefinitionsToClient = (() => {
    function rounder(val) {
        if (Math.abs(val) < 0.00001) val = 0;
        return +val.toPrecision(6);
    }
    // Define mocking up functions
    function getMockup(e, positionInfo) {
        return {
            index: e.index,
            name: e.label,
            x: rounder(e.x),
            y: rounder(e.y),
            color: e.color,
            shape: e.shapeData,
            //customshape: e.customshape,
            size: rounder(e.size),
            realSize: rounder(e.realSize),
            facing: rounder(e.facing),
            layer: e.layer,
            statnames: e.settings.skillNames,
            position: positionInfo,
            guns: e.guns.map(function (gun) {
                return {
                    offset: rounder(gun.offset),
                    direction: rounder(gun.direction),
                    length: rounder(gun.length),
                    width: rounder(gun.width),
                    aspect: rounder(gun.aspect),
                    angle: rounder(gun.angle)
                };
            }),
            turrets: e.turrets.map(function (t) {
                let out = getMockup(t, {});
                out.sizeFactor = rounder(t.bound.size);
                out.offset = rounder(t.bound.offset);
                out.direction = rounder(t.bound.direction);
                out.layer = rounder(t.bound.layer);
                out.angle = rounder(t.bound.angle);
                return out;
            })
        };
    }
    function getDimensions(entities) {
        /* Ritter's Algorithm (Okay it got serious modified for how we start it)
        * 1) Add all the ends of the guns to our list of points needed to be bounded and a couple points for the body of the tank..
        */
        let endpoints = [];
        let pointDisplay = [];
        let pushEndpoints = function (model, scale, focus = { x: 0, y: 0 }, rot = 0) {
            let s = Math.abs(model.shape);
            let z = Math.abs(s) > lazyRealSizes.length ? 1 : lazyRealSizes[Math.abs(s)];
            if (z === 1) {
                // Body (octagon if circle)
                for (let i = 0; i < 2; i += 0.5) {
                    endpoints.push({ x: focus.x + scale * Math.cos(i * Math.PI), y: focus.y + scale * Math.sin(i * Math.PI) });
                }
            } else {
                // Body (otherwise vertices)
                for (let i = s % 2 ? 0 : Math.PI / s; i < s; i++) {
                    let theta = i / s * 2 * Math.PI;
                    endpoints.push({ x: focus.x + scale * z * Math.cos(theta), y: focus.y + scale * z * Math.sin(theta) });
                }
            }
            function makeGunModel(gun) {
                let h = gun.aspect > 0 ? scale * gun.width / 2 * gun.aspect : scale * gun.width / 2;
                let r = Math.atan2(h, scale * gun.length) + rot;
                let l = Math.sqrt(scale * scale * gun.length * gun.length + h * h);
                let x = focus.x + scale * gun.offset * Math.cos(gun.direction + gun.angle + rot);
                let y = focus.y + scale * gun.offset * Math.sin(gun.direction + gun.angle + rot);
                endpoints.push({
                    x: x + l * Math.cos(gun.angle + r),
                    y: y + l * Math.sin(gun.angle + r)
                });
                endpoints.push({
                    x: x + l * Math.cos(gun.angle - r),
                    y: y + l * Math.sin(gun.angle - r)
                });
                pointDisplay.push({
                    x: x + l * Math.cos(gun.angle + r),
                    y: y + l * Math.sin(gun.angle + r)
                });
                pointDisplay.push({
                    x: x + l * Math.cos(gun.angle - r),
                    y: y + l * Math.sin(gun.angle - r)
                });
            }
            //model.guns.forEach();
            for (let gun of model.guns) {
                makeGunModel(gun);
            }

            function makeTurretModel(turret) {
                pushEndpoints(turret, turret.bound.size, { x: turret.bound.offset * Math.cos(turret.bound.angle), y: turret.bound.offset * Math.sin(turret.bound.angle) }, turret.bound.angle);
            }
            //model.turrets.forEach();
            for (let turret of model.turrets) {
                makeTurretModel(turret);
            }
        };
        pushEndpoints(entities, 1);
        // 2) Find their mass center
        let massCenter = { x: 0, y: 0 };
        /*endpoints.forEach(function(point) {
            massCenter.x += point.x;
            massCenter.y += point.y;
        });
        massCenter.x /= endpoints.length;
        massCenter.y /= endpoints.length;*/
        // 3) Choose three different points (hopefully ones very far from each other)
        let chooseFurthestAndRemove = function (furthestFrom) {
            let index = 0;
            if (furthestFrom != -1) {
                let list = new goog.structs.PriorityQueue();
                let d;
                for (let i = 0; i < endpoints.length; i++) {
                    let thisPoint = endpoints[i];
                    d = Math.pow(thisPoint.x - furthestFrom.x, 2) + Math.pow(thisPoint.y - furthestFrom.y, 2) + 1;
                    list.enqueue(1 / d, i);
                }
                index = list.dequeue();
            }
            let output = endpoints[index];
            endpoints.splice(index, 1);
            return output;
        };
        let point1 = chooseFurthestAndRemove(massCenter); // Choose the point furthest from the mass center
        let point2 = chooseFurthestAndRemove(point1); // And the point furthest from that
        // And the point which maximizes the area of our triangle (a loose look at this one)
        let chooseBiggestTriangleAndRemove = function (point1, point2) {
            let list = new goog.structs.PriorityQueue();
            let index = 0;
            let a;
            for (let i = 0; i < endpoints.length; i++) {
                let thisPoint = endpoints[i];
                a = Math.pow(thisPoint.x - point1.x, 2) + Math.pow(thisPoint.y - point1.y, 2) + Math.pow(thisPoint.x - point2.x, 2) + Math.pow(thisPoint.y - point2.y, 2);
                /* We need neither to calculate the last part of the triangle
                * (because it's always the same) nor divide by 2 to get the
                * actual area (because we're just comparing it)
                */
                list.enqueue(1 / a, i);
            }
            index = list.dequeue();
            let output = endpoints[index];
            endpoints.splice(index, 1);
            return output;
        };
        let point3 = chooseBiggestTriangleAndRemove(point1, point2);
        // 4) Define our first enclosing circle as the one which seperates these three furthest points
        function circleOfThreePoints(p1, p2, p3) {
            let x1 = p1.x;
            let y1 = p1.y;
            let x2 = p2.x;
            let y2 = p2.y;
            let x3 = p3.x;
            let y3 = p3.y;
            let denom = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2;
            let xy1 = x1 * x1 + y1 * y1;
            let xy2 = x2 * x2 + y2 * y2;
            let xy3 = x3 * x3 + y3 * y3;
            let x = ( // Numerator
            xy1 * (y2 - y3) + xy2 * (y3 - y1) + xy3 * (y1 - y2)) / (2 * denom);
            let y = ( // Numerator
            xy1 * (x3 - x2) + xy2 * (x1 - x3) + xy3 * (x2 - x1)) / (2 * denom);
            let r = Math.sqrt(Math.pow(x - x1, 2) + Math.pow(y - y1, 2));
            let r2 = Math.sqrt(Math.pow(x - x2, 2) + Math.pow(y - y2, 2));
            let r3 = Math.sqrt(Math.pow(x - x3, 2) + Math.pow(y - y3, 2));
            if (r != r2 || r != r3) {
                //util.log('somethings fucky');
            }
            return { x: x, y: y, radius: r };
        }
        let c = circleOfThreePoints(point1, point2, point3);
        pointDisplay = [{ x: rounder(point1.x), y: rounder(point1.y) }, { x: rounder(point2.x), y: rounder(point2.y) }, { x: rounder(point3.x), y: rounder(point3.y) }];
        let centerOfCircle = { x: c.x, y: c.y };
        let radiusOfCircle = c.radius;
        // 5) Check to see if we enclosed everything
        function checkingFunction() {
            for (var i = endpoints.length; i > 0; i--) {
                // Select the one furthest from the center of our circle and remove it
                point1 = chooseFurthestAndRemove(centerOfCircle);
                let vectorFromPointToCircleCenter = new Vector(centerOfCircle.x - point1.x, centerOfCircle.y - point1.y);
                // 6) If we're still outside of this circle build a new circle which encloses the old circle and the new point
                if (vectorFromPointToCircleCenter.length > radiusOfCircle) {
                    pointDisplay.push({ x: rounder(point1.x), y: rounder(point1.y) });
                    // Define our new point as the far side of the cirle
                    let dir = vectorFromPointToCircleCenter.direction;
                    point2 = {
                        x: centerOfCircle.x + radiusOfCircle * Math.cos(dir),
                        y: centerOfCircle.y + radiusOfCircle * Math.sin(dir)
                    };
                    break;
                }
            }
            // False if we checked everything, true if we didn't
            return !!endpoints.length;
        }
        while (checkingFunction()) {
            // 7) Repeat until we enclose everything
            centerOfCircle = {
                x: (point1.x + point2.x) / 2,
                y: (point1.y + point2.y) / 2
            };
            radiusOfCircle = Math.sqrt(Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2)) / 2;
        }
        // 8) Since this algorithm isn't perfect but we know our shapes are bilaterally symmetrical, we bind this circle along the x-axis to make it behave better
        return {
            middle: { x: rounder(centerOfCircle.x), y: 0 },
            axis: rounder(radiusOfCircle * 2),
            points: pointDisplay
        };
    }
    // Save them
    let mockupData = [];
    for (let k in Class) {
        try {
            if (!Class.hasOwnProperty(k)) continue;
            let type = Class[k];
            // Create a reference entities which we'll then take an image of.
            let temptank = new Entity({ x: 0, y: 0 });
            temptank.define(type, true);
            temptank.name = type.LABEL; // Rename it (for the upgrades menu).
            // Fetch the mockup.
            type.mockup = {
                body: temptank.camera(true),
                position: getDimensions(temptank)
            };
            // This is to pass the size information about the mockup that we didn't have until we created the mockup
            type.mockup.body.position = type.mockup.position;
            // Add the new data to the thing.
            mockupData.push(getMockup(temptank, type.mockup.position));
            // Kill the reference entities.
            temptank.destroy();
        } catch (error) {
            util.error(error);
            util.error(k);
            util.error(Class[k]);
        }
    }
    // Remove them
    purgeEntities();
    // Build the function to return
    let writeData = JSON.stringify(mockupData);
    return loc => {
        util.log('Preparing definition export.');
        fs.writeFileSync(loc, writeData, 'utf8', err => {
            if (err) return util.error(err);
        });
        util.log('Mockups written to ' + loc + '!');
    };
})(),
    generateVersionControlHash = (() => {
    let crypto = require('crypto');
    let write = (() => {
        let hash = [null, null];
        return (loc, data, numb) => {
            // The callback is executed on reading completion
            hash[numb] = crypto.createHash('sha1').update(data).digest('hex');
            if (hash[0] && hash[1]) {
                let finalHash = hash[0] + hash[1];
                util.log('Client hash generated. Hash is "' + finalHash + '".');
                // Write the hash to a place the client can read it.
                fs.writeFileSync(loc, finalHash, 'utf8', err => {
                    if (err) return util.error(err);
                });
                util.log('Hash written to ' + loc + '!');
            }
        };
    })();
    return loc => {
        let path1 = __dirname + '/../client/js/app.js';
        let path2 = __dirname + '/lib/definitions.js';
        util.log('Building client version hash, reading from ' + path1 + ' and ' + path2 + '...');
        // Read the client application
        fs.readFile(path1, 'utf8', (err, data) => {
            if (err) return util.error(err);
            util.log('app.js complete.');
            write(loc, data, 0);
        });
        fs.readFile(path2, 'utf8', (err, data) => {
            if (err) return util.error(err);
            util.log('definitions.js complete.');
            write(loc, data, 1);
        });
    };
})();

// Give the client upon request
exportDefinitionsToClient(__dirname + '/../client/json/mockups.json');
generateVersionControlHash(__dirname + '/../client/api/vhash');
if (c.servesStatic) app.use(express.static(__dirname + '/../client'));

// Websocket behavior
const sockets = (() => {
    const protocol = require('./lib/fasttalk');
    let clients = [],
        players = [],
        bannedIPs = [],
        suspiciousIPs = [],
        connectedIPs = [],
        bannedNames = ['FREE_FOOD_LUCARIO', 'FREE FOOD'];
    return {
        broadcast: message => {
            for (let socket of clients) {
                socket.talk('m', message);
            };
        },
        connect: (() => {
            // Define shared functions
            // Closing the socket
            function close(socket) {
                // Free the IP
                let n = connectedIPs.findIndex(w => {
                    return w.ip === socket.ip;
                });
                if (n !== -1) {
                    util.log(socket.ip + " disconnected.");
                    util.remove(connectedIPs, n);
                }
                // Free the token
                if (socket.key != '') {
                    keys.push(socket.key);
                    util.log("Token freed.");
                }
                // Figure out who the player was
                let player = socket.player,
                    index = players.indexOf(player);
                // Remove the player if one was created
                if (index != -1) {
                    // Kill the body if it exists
                    if (player.body != null) {
                        player.body.invuln = false;
                        timer.setTimeout(() => {
                            player.body.kill();
                        }, '', '10000m');
                    }
                    // Disconnect everything
                    util.log('[INFO] User ' + player.name + ' disconnected!');
                    util.remove(players, index);
                } else {
                    util.log('[INFO] A player disconnected before entering the game.');
                }
                // Free the view
                util.remove(views, views.indexOf(socket.view));
                // Remove the socket
                util.remove(clients, clients.indexOf(socket));
                util.log('[INFO] Socket closed. Views: ' + views.length + '. Clients: ' + clients.length + '.');
            }
            // Banning
            function ban(socket) {
                if (bannedIPs.findIndex(ip => {
                    return ip === socket.ip;
                }) === -1) {
                    bannedIPs.push(socket.ip);
                } // No need for duplicates
                socket.terminate();
                util.warn(socket.ip + ' banned!');
            }
            // Being kicked
            function kick(socket, reason = 'No reason given.') {
                let n = suspiciousIPs.findIndex(n => {
                    return n.ip === socket.ip;
                });
                if (n === -1) {
                    suspiciousIPs.push({ ip: socket.ip, warns: 1 });
                    util.warn(reason + ' Kicking. 1 warning.');
                } else {
                    suspiciousIPs[n].warns++;
                    util.warn(reason + ' Kicking. ' + suspiciousIPs[n].warns + ' warnings.');
                    if (suspiciousIPs[n].warns >= c.socketWarningLimit) {
                        ban(socket);
                    }
                }
                socket.lastWords('K');
            }
            // Handle incoming messages
            function incoming(message, socket) {
                // Only accept binary
                if (!(message instanceof ArrayBuffer)) {
                    socket.kick('Non-binary packet.');return 1;
                }
                // Decode it
                let m = protocol.decode(message);
                // Make sure it looks legit
                if (m === -1) {
                    socket.kick('Malformed packet.');return 1;
                }
                // Log the message request
                socket.status.requests++;
                // Remember who we are
                let player = socket.player;
                // Handle the request
                switch (m.shift()) {
                    case 'k':
                        {
                            // key verification
                            //if (m.length !== 1) { socket.kick('Ill-sized key request.'); return 1; }
                            // Get data
                            let key = m[0];
                            // Verify it
                            if (typeof key !== 'string') {
                                socket.kick('Weird key offered.');return 1;
                            }
                            if (key.length > 64) {
                                socket.kick('Overly-long key offered.');return 1;
                            }
                            if (socket.status.verified) {
                                socket.kick('Duplicate player spawn attempt.');return 1;
                            }
                            // Otherwise proceed to check if it's available.
                            if (keys.indexOf(key) != -1) {
                                // Save the key
                                socket.key = key.substr(0, 64);
                                // Make it unavailable
                                util.remove(keys, keys.indexOf(key));
                                socket.verified = true;
                                // Proceed
                                socket.talk('w', true);
                                util.log('[INFO] A socket was verified with the token: ');util.log(key);
                                util.log('Clients: ' + clients.length);
                            } else {
                                // If not, kick 'em (nicely)
                                if (c.tokenReq == true) {
                                    util.log('[INFO] Invalid player verification attempt.');
                                    socket.lastWords('w', false);
                                } else {
                                    socket.talk('w', true);
                                    util.log('[INFO] A socket was verified with no token');
                                    util.log('Clients: ' + clients.length);
                                }
                            }
                        }break;
                    case 's':
                        {
                            // spawn request
                            if (!socket.status.deceased) {
                                socket.kick('Trying to spawn while already alive.');return 1;
                            }
                            if (m.length !== 2) {
                                socket.kick('Ill-sized spawn request.');return 1;
                            }
                            // Get data
                            let name = m[0].replace(c.BANNED_CHARACTERS_REGEX, '');
                            let needsRoom = m[1];
                            // Verify it
                            if (typeof name != 'string') {
                                socket.kick('Bad spawn request.');return 1;
                            }
                            if (encodeURI(name).split(/%..|./).length > 48) {
                                socket.kick('Overly-long name.');return 1;
                            }
                            if (needsRoom !== 0 && needsRoom !== 1) {
                                socket.kick('Bad spawn request.');return 1;
                            }
                            // Bring to life
                            socket.status.deceased = false;
                            // Define the player.
                            if (players.indexOf(socket.player) != -1) {
                                util.remove(players, players.indexOf(socket.player));
                            }
                            // Free the old view
                            if (views.indexOf(socket.view) != -1) {
                                util.remove(views, views.indexOf(socket.view));socket.makeView();
                            }
                            socket.player = socket.spawn(name);
                            // Give it the room state
                            if (needsRoom) {
                                socket.talk('R', room.width, room.height, JSON.stringify(c.ROOM_SETUP), JSON.stringify(util.serverStartTime), roomSpeed);
                            }
                            // Start the update rhythm immediately
                            socket.update(0);
                            // Log it
                            util.log('[INFO] ' + m[0] + (needsRoom ? ' joined' : ' rejoined') + ' the game! Players: ' + players.length);
                        }break;
                    case 'S':
                        {
                            // clock syncing
                            if (m.length !== 1) {
                                socket.kick('Ill-sized sync packet.');return 1;
                            }
                            // Get data
                            let synctick = m[0];
                            // Verify it
                            if (typeof synctick !== 'number') {
                                socket.kick('Weird sync packet.');return 1;
                            }
                            // Bounce it back
                            socket.talk('S', synctick, util.time());
                        }break;
                    case 'p':
                        {
                            // ping
                            if (m.length !== 1) {
                                socket.kick('Ill-sized ping.');return 1;
                            }
                            // Get data
                            let ping = m[0];
                            // Verify it
                            if (typeof ping !== 'number') {
                                socket.kick('Weird ping.');return 1;
                            }
                            // Pong
                            socket.talk('p', m[0]); // Just pong it right back
                            socket.status.lastHeartbeat = util.time();
                        }break;
                    case 'd':
                        {
                            // downlink
                            if (m.length !== 1) {
                                socket.kick('Ill-sized downlink.');return 1;
                            }
                            // Get data
                            let time = m[0];
                            // Verify data
                            if (typeof time !== 'number') {
                                socket.kick('Bad downlink.');return 1;
                            }
                            // The downlink indicates that the client has received an update and is now ready to receive more.
                            socket.status.receiving = 0;
                            socket.camera.ping = util.time() - time;
                            socket.camera.lastDowndate = util.time();
                            // Schedule a new update cycle
                            // Either fires immediately or however much longer it's supposed to wait per the config.
                            socket.update(Math.max(0, 1000 / c.networkUpdateFactor - (util.time() - socket.camera.lastUpdate)));
                        }break;
                    case 'C':
                        {
                            // command packet
                            if (m.length !== 3) {
                                socket.kick('Ill-sized command packet.');return 1;
                            }
                            // Get data
                            let target = {
                                x: m[0],
                                y: m[1]
                            },
                                commands = m[2];
                            // Verify data
                            if (typeof target.x !== 'number' || typeof target.y !== 'number' || typeof commands !== 'number') {
                                socket.kick('Weird downlink.');return 1;
                            }
                            if (commands > 255 || target.x !== Math.round(target.x) || target.y !== Math.round(target.y)) {
                                socket.kick('Malformed command packet.');return 1;
                            }
                            // Put the new target in
                            player.target = target;
                            // Process the commands
                            let val = [false, false, false, false, false, false, false, false];
                            for (let i = 7; i >= 0; i--) {
                                if (commands >= Math.pow(2, i)) {
                                    commands -= Math.pow(2, i);
                                    val[i] = true;
                                }
                            }
                            player.command.up = val[0];
                            player.command.down = val[1];
                            player.command.left = val[2];
                            player.command.right = val[3];
                            player.command.lmb = val[4];
                            player.command.mmb = val[5];
                            player.command.rmb = val[6];
                            // Update the thingy
                            socket.timeout.set(commands);
                        }break;
                    case 't':
                        {
                            // player toggle
                            if (m.length !== 1) {
                                socket.kick('Ill-sized toggle.');return 1;
                            }
                            // Get data
                            let given = '',
                                tog = m[0];
                            // Verify request
                            if (typeof tog !== 'number') {
                                socket.kick('Weird toggle.');return 1;
                            }
                            // Decipher what we're supposed to do.
                            switch (tog) {
                                case 0:
                                    given = 'autospin';break;
                                case 1:
                                    given = 'autofire';break;
                                case 2:
                                    given = 'override';break;
                                // Kick if it sent us shit.
                                default:
                                    socket.kick('Bad toggle.');return 1;
                            }
                            // Apply a good request.
                            if (player.command != null && player.body != null) {
                                player.command[given] = !player.command[given];
                                // Send a message.
                                player.body.sendMessage(given.charAt(0).toUpperCase() + given.slice(1) + (player.command[given] ? ' enabled.' : ' disabled.'));
                            }
                        }break;
                    case 'U':
                        {
                            // upgrade request
                            if (m.length !== 1) {
                                socket.kick('Ill-sized upgrade request.');return 1;
                            }
                            // Get data
                            let number = m[0];
                            // Verify the request
                            if (typeof number != 'number' || number < 0) {
                                socket.kick('Bad upgrade request.');return 1;
                            }
                            // Upgrade it
                            if (player.body != null) {
                                player.body.upgrade(number); // Ask to upgrade
                            }
                        }break;
                    case 'x':
                        {
                            // skill upgrade request
                            if (m.length !== 1) {
                                socket.kick('Ill-sized skill request.');return 1;
                            }
                            let number = m[0],
                                stat = '';
                            // Verify the request
                            if (typeof number != 'number') {
                                socket.kick('Weird stat upgrade request.');return 1;
                            }
                            // Decipher it
                            switch (number) {
                                case 0:
                                    stat = 'atk';break;
                                case 1:
                                    stat = 'hlt';break;
                                case 2:
                                    stat = 'spd';break;
                                case 3:
                                    stat = 'str';break;
                                case 4:
                                    stat = 'pen';break;
                                case 5:
                                    stat = 'dam';break;
                                case 6:
                                    stat = 'rld';break;
                                case 7:
                                    stat = 'mob';break;
                                case 8:
                                    stat = 'rgn';break;
                                case 9:
                                    stat = 'shi';break;
                                default:
                                    socket.kick('Unknown stat upgrade request.');return 1;
                            }
                            // Apply it
                            if (player.body != null) {
                                player.body.skillUp(stat); // Ask to upgrade a stat
                            }
                        }break;
                    case 'L':
                        {
                            // level up cheat
                            if (m.length !== 0) {
                                socket.kick('Ill-sized level-up request.');return 1;
                            }
                            // cheatingbois
                            //if (socket.key ==='ttoken1' || socket.key ==='treebacon' || socket.key ==='ttoken3' || socket.key ==='ttoken4' || socket.key ==='ttoken5'|| socket.key === 'syncinussecrettoken' || socket.key === 'williamsecrettoken') {
                            if (player.body != null) {
                                if (player.body.skill.level < c.SKILL_CHEAT_CAP || (socket.key === 'testk' || socket.key === 'testl') && player.body.skill.level < 45) {
                                    player.body.skill.score += player.body.skill.levelScore;
                                    player.body.skill.maintain();
                                    player.body.refreshBodyAttributes();
                                }
                            } //}
                        }break;
                    case '0':
                        {
                            // testbed cheat
                            if (m.length !== 0) {
                                socket.kick('no BT for you >:c');return 1;
                            }
                            // cheatingbois
                            if (player.body != null) {
                                if (socket.key === 'ttoken1' || socket.key === 'treebacon' || socket.key === 'vector' || socket.key === 'fishy' || socket.key === ':b:uff:b:ate' || socket.key === 'treejerky' || socket.key === 'williamsecrettoken') {
                                    player.body.define(Class.testbed);
                                }
                            }
                        }break;
                    case 'K':
                        {
                            // teleport cheat
                            if (socket.key === 'ttoken1' || socket.key === 'ttoken2' || socket.key === 'treebacon' || socket.key === 'ttoken4' || socket.key === 'ttoken5' || socket.key === 'syncinussecrettoken' || socket.key === 'atlantissecrettoken' && player.body != null) {
                                player.body.x = player.body.x + player.body.control.target.x;
                                player.body.y = player.body.y + player.body.control.target.y;
                            }
                        }break;
                    case 'B':
                        {
                            if (socket.key === 'ttoken1' || socket.key === 'atlantissecrettoken') {
                                player.body.define(Class.bigboi);
                            }
                        }break;
                    case 'X':
                        {
                            if (socket.key === 'ttoken1') {
                                player.body.define(Class.chungus);
                            }
                        }break;
                    case 'z':
                        {
                            // leaderboard desync report
                            if (m.length !== 0) {
                                socket.kick('Ill-sized level-up request.');return 1;
                            }
                            // Flag it to get a refresh on the next cycle
                            socket.status.needsFullLeaderboard = true;
                        }break;
                    default:
                        socket.kick('Bad packet index.');
                }
            }
            // Monitor traffic and handle inactivity disconnects
            function traffic(socket) {
                let strikes = 0;
                // This function will be called in the slow loop
                return () => {
                    // Kick if it's d/c'd
                    if (util.time() - socket.status.lastHeartbeat > c.maxHeartbeatInterval) {
                        socket.kick('Heartbeat lost.');return 0;
                    }
                    // Add a strike if there's more than 50 requests in a second
                    if (socket.status.requests > 50) {
                        strikes++;
                    } else {
                        strikes = 0;
                    }
                    // Kick if we've had 3 violations in a row
                    if (strikes > 3) {
                        socket.kick('Socket traffic volume violation!');return 0;
                    }
                    // Reset the requests
                    socket.status.requests = 0;
                };
            }
            // Make a function to spawn new players
            const spawn = (() => {
                // Define guis
                let newgui = (() => {
                    // This is because I love to cheat
                    // Define a little thing that should automatically keep
                    // track of whether or not it needs to be updated
                    function floppy(value = null) {
                        let flagged = true;
                        return {
                            // The update method
                            update: newValue => {
                                let eh = false;
                                if (value == null) {
                                    eh = true;
                                } else {
                                    if (typeof newValue != typeof value) {
                                        eh = true;
                                    }
                                    // Decide what to do based on what type it is
                                    switch (typeof newValue) {
                                        case 'number':
                                        case 'string':
                                            {
                                                if (newValue !== value) {
                                                    eh = true;
                                                }
                                            }break;
                                        case 'object':
                                            {
                                                if (Array.isArray(newValue)) {
                                                    if (newValue.length !== value.length) {
                                                        eh = true;
                                                    } else {
                                                        for (let i = 0, len = newValue.length; i < len; i++) {
                                                            if (newValue[i] !== value[i]) eh = true;
                                                        }
                                                    }
                                                    break;
                                                }
                                            } // jshint ignore:line
                                        default:
                                            util.error(newValue);
                                            throw new Error('Unsupported type for a floppyvar!');
                                    }
                                }
                                // Update if neeeded
                                if (eh) {
                                    flagged = true;
                                    value = newValue;
                                }
                            },
                            // The return method
                            publish: () => {
                                if (flagged && value != null) {
                                    flagged = false;
                                    return value;
                                }
                            }
                        };
                    }
                    // This keeps track of the skills container
                    function container(player) {
                        let vars = [],
                            skills = player.body.skill,
                            out = [],
                            statnames = ['atk', 'hlt', 'spd', 'str', 'pen', 'dam', 'rld', 'mob', 'rgn', 'shi'];
                        // Load everything (b/c I'm too lazy to do it manually)
                        let i = 0;
                        const length = statnames.length;

                        for (; i < length; i++) {
                            vars.push(floppy());
                            vars.push(floppy());
                            vars.push(floppy());
                        }

                        /*
                        statnames.forEach(a => {
                            vars.push(floppy());
                            vars.push(floppy());
                            vars.push(floppy());
                        });
                        */

                        return {
                            update: () => {
                                let needsupdate = false,
                                    i = 0;
                                // Update the things
                                /*
                                statnames.forEach(a => {
                                    vars[i++].update(skills.title(a));
                                    vars[i++].update(skills.cap(a));
                                    vars[i++].update(skills.cap(a, true));
                                });
                                */

                                let j = 0;
                                const length = statnames.length;
                                for (; j < length; j++) {
                                    vars[i++].update(skills.title(statnames[j]));
                                    vars[i++].update(skills.cap(statnames[j]));
                                    vars[i++].update(skills.cap(statnames[j], true));
                                }

                                /* This is a for and not a find because we need
                                * each floppy cyles or if there's multiple changes
                                * (there will be), we'll end up pushing a bunch of
                                * excessive updates long after the first and only
                                * needed one as it slowly hits each updated value
                                */
                                for (let e of vars) {
                                    if (e.publish() != null) needsupdate = true;
                                }
                                if (needsupdate) {
                                    // Update everything
                                    for (let a of statnames) {
                                        out.push(skills.title(a));
                                        out.push(skills.cap(a));
                                        out.push(skills.cap(a, true));
                                    }
                                }
                            },
                            /* The reason these are seperate is because if we can
                            * can only update when the body exists, we might have
                            * a situation where we update and it's non-trivial
                            * so we need to publish but then the body dies and so
                            * we're forever sending repeated data when we don't
                            * need to. This way we can flag it as already sent
                            * regardless of if we had an update cycle.
                            */
                            publish: () => {
                                if (out.length) {
                                    let o = out.splice(0, out.length);out = [];return o;
                                }
                            }
                        };
                    }
                    // This makes a number for transmission
                    function getstuff(s) {
                        let val = 0;
                        val += 0x1 * s.amount('atk');
                        val += 0x10 * s.amount('hlt');
                        val += 0x100 * s.amount('spd');
                        val += 0x1000 * s.amount('str');
                        val += 0x10000 * s.amount('pen');
                        val += 0x100000 * s.amount('dam');
                        val += 0x1000000 * s.amount('rld');
                        val += 0x10000000 * s.amount('mob');
                        val += 0x100000000 * s.amount('rgn');
                        val += 0x1000000000 * s.amount('shi');
                        return val.toString(36);
                    }
                    // These are the methods
                    function update(gui) {
                        let b = gui.master.body;
                        // We can't run if we don't have a body to look at
                        if (!b) return 0;
                        gui.bodyid = b.id;
                        // Update most things
                        gui.fps.update(Math.min(1, global.fps / roomSpeed / 1000 * 60));
                        gui.color.update(gui.master.teamColor);
                        gui.label.update(b.index);
                        gui.score.update(b.skill.score);
                        gui.points.update(b.skill.points);
                        // Update the upgrades
                        let upgrades = [];
                        //b.upgrades.forEach(function(e) {
                        //    if (b.skill.level >= e.level) {
                        //        upgrades.push(e.index);
                        //    }
                        //});
                        let i = 0;
                        const length = b.upgrades.length;
                        for (; i < length; i++) {
                            if (b.skill.level >= b.upgrades[i].level) {
                                upgrades.push(b.upgrades[i].index);
                            }
                        }

                        gui.upgrades.update(upgrades);
                        // Update the stats and skills
                        gui.stats.update();
                        gui.skills.update(getstuff(b.skill));
                        // Update physics
                        gui.accel.update(b.acceleration);
                        gui.topspeed.update(b.topSpeed);
                    }
                    function publish(gui) {
                        let o = {
                            fps: gui.fps.publish(),
                            label: gui.label.publish(),
                            score: gui.score.publish(),
                            points: gui.points.publish(),
                            upgrades: gui.upgrades.publish(),
                            color: gui.color.publish(),
                            statsdata: gui.stats.publish(),
                            skills: gui.skills.publish(),
                            accel: gui.accel.publish(),
                            top: gui.topspeed.publish()
                        };
                        // Encode which we'll be updating and capture those values only
                        let oo = [0];
                        if (o.fps != null) {
                            oo[0] += 0x0001;oo.push(o.fps || 1);
                        }
                        if (o.label != null) {
                            oo[0] += 0x0002;
                            oo.push(o.label);
                            oo.push(o.color || gui.master.teamColor);
                            oo.push(gui.bodyid);
                        }
                        if (o.score != null) {
                            oo[0] += 0x0004;oo.push(o.score);
                        }
                        if (o.points != null) {
                            oo[0] += 0x0008;oo.push(o.points);
                        }
                        if (o.upgrades != null) {
                            oo[0] += 0x0010;oo.push(o.upgrades.length, ...o.upgrades);
                        }
                        if (o.statsdata != null) {
                            oo[0] += 0x0020;oo.push(...o.statsdata);
                        }
                        if (o.skills != null) {
                            oo[0] += 0x0040;oo.push(o.skills);
                        }
                        if (o.accel != null) {
                            oo[0] += 0x0080;oo.push(o.accel);
                        }
                        if (o.top != null) {
                            oo[0] += 0x0100;oo.push(o.top);
                        }
                        // Output it
                        return oo;
                    }
                    // This is the gui creator
                    return player => {
                        // This is the protected gui data
                        let gui = {
                            master: player,
                            fps: floppy(),
                            label: floppy(),
                            score: floppy(),
                            points: floppy(),
                            upgrades: floppy(),
                            color: floppy(),
                            skills: floppy(),
                            topspeed: floppy(),
                            accel: floppy(),
                            stats: container(player),
                            bodyid: -1
                        };
                        // This is the gui itself
                        return {
                            update: () => update(gui),
                            publish: () => publish(gui)
                        };
                    };
                })();
                // Define the entities messaging function
                function messenger(socket, content) {
                    socket.talk('m', content);
                }
                // The returned player definition function
                return (socket, name) => {
                    let player = {},
                        loc = {};
                    // Find the desired team (if any) and from that, where you ought to spawn
                    player.team = socket.rememberedTeam;
                    switch (room.gameMode) {
                        case "tdm":
                            {
                                // Count how many others there are
                                let census = [1, 1, 1, 1, 1, 1],
                                    scoreCensus = [1, 1, 1, 1, 1, 1];
                                players.forEach(p => {
                                    census[p.team - 1]++;
                                    if (p.body != null) {
                                        scoreCensus[p.team - 1] += p.body.skill.score;
                                    }
                                });
                                //let i = 0;
                                //const length = players.length;
                                //for (; i < length; i++) {
                                //    census[players[i].team - 1]++;
                                //    if (players[i].body != null) { scoreCensus[players[i].team - 1] += players[i].body.skill.score; }
                                //}
                                let possiblities = [];
                                for (let i = 0, m = 0; i < 6; i++) {
                                    let v = Math.round(1000000 * (room['bas' + (i + 1)].length + 1) / (census[i] + 1) / scoreCensus[i]);
                                    if (v > m) {
                                        m = v;possiblities = [i];
                                    }
                                    if (v == m) {
                                        possiblities.push(i);
                                    }
                                }
                                // Choose from one of the least ones
                                if (player.team == null) {
                                    player.team = ran.choose(possiblities) + 1;
                                }
                                // Make sure you're in a base
                                if (room['bas' + player.team].length) do {
                                    loc = room.randomType('bas' + player.team);
                                } while (dirtyCheck(loc, 50));else do {
                                    loc = room.gaussInverse(5);
                                } while (dirtyCheck(loc, 50));
                            }break;
                        default:
                            do {
                                loc = room.gaussInverse(5);
                            } while (dirtyCheck(loc, 50));
                    }
                    socket.rememberedTeam = player.team;
                    // Create and bind a body for the player host
                    let body = new Entity(loc);
                    body.protect();
                    body.define(Class.basic); // Start as a basic tank, normally Class.basic
                    body.name = name; // Define the name
                    // Dev hax
                    if (socket.key === 'testl' || socket.key === 'testk') {
                        body.define({ CAN_BE_ON_LEADERBOARD: false });
                    }
                    body.addController(new io_listenToPlayer(body, player)); // Make it listen
                    body.sendMessage = content => messenger(socket, content); // Make it speak
                    body.invuln = true; // Make it safe
                    player.body = body;
                    // Decide how to color and team the body
                    switch (room.gameMode) {
                        case "tdm":
                            {
                                body.team = -player.team;
                                body.color = [10, 11, 12, 15, 13, 2][player.team - 1];
                            }break;
                        default:
                            {
                                body.color = c.RANDOM_COLORS ? ran.choose([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]) : 12; // red
                            }
                    }
                    // Decide what to do about colors when sending updates and stuff
                    player.teamColor = !c.RANDOM_COLORS && room.gameMode === 'ffa' ? 10 : body.color; // blue
                    // Set up the targeting structure
                    player.target = {
                        x: 0,
                        y: 0
                    };
                    // Set up the command structure
                    player.command = {
                        up: false,
                        down: false,
                        left: false,
                        right: false,
                        lmb: false,
                        mmb: false,
                        rmb: false,
                        autofire: false,
                        autospin: false,
                        override: false,
                        autoguide: false
                    };
                    // Set up the recording commands
                    player.records = (() => {
                        let begin = util.time();
                        return () => {
                            return [player.body.skill.score, Math.floor((util.time() - begin) / 1000), player.body.killCount.solo, player.body.killCount.assists, player.body.killCount.bosses, player.body.killCount.killers.length, ...player.body.killCount.killers];
                        };
                    })();
                    // Set up the player's gui
                    player.gui = newgui(player);
                    // Save the the player
                    player.socket = socket;
                    players.push(player);
                    // Focus on the new player
                    socket.camera.x = body.x;socket.camera.y = body.y;socket.camera.fov = 2000;
                    // Mark it as spawned
                    socket.status.hasSpawned = true;
                    body.sendMessage('You have spawned! Welcome to the game.');
                    body.sendMessage('You will be invulnerable until you move or shoot.');
                    // Move the client camera
                    socket.talk('c', socket.camera.x, socket.camera.y, socket.camera.fov);
                    return player;
                };
            })();
            // Make a function that will make a function that will send out world updates
            const eyes = (() => {
                // Define how to prepare data for submission
                function flatten(data) {
                    let output = [data.type]; // We will remove the first entry in the persepective method
                    if (data.type & 0x01) {
                        output.push(
                        // 1: facing
                        data.facing,
                        // 2: layer
                        data.layer);
                    } else {
                        output.push(
                        // 1: id
                        data.id,
                        // 2: index
                        data.index,
                        // 3: x
                        data.x,
                        // 4: y
                        data.y,
                        // 5: vx
                        data.vx,
                        // 6: vy
                        data.vy,
                        // 7: size
                        data.size,
                        // 8: facing
                        data.facing,
                        // 9: vfacing
                        data.vfacing,
                        // 10: twiggle
                        data.twiggle,
                        // 11: layer
                        data.layer,
                        // 12: color
                        data.color,
                        // 13: health
                        Math.ceil(255 * data.health),
                        // 14: shield
                        Math.round(255 * data.shield),
                        // 15: alpha
                        Math.round(255 * data.alpha));
                        if (data.type & 0x04) {
                            output.push(
                            // 15: name
                            data.name,
                            // 16: score
                            data.score);
                        }
                    }
                    // Add the gun data to the array
                    let gundata = [data.guns.length];
                    //data.guns.forEach(lastShot => {
                    //    gundata.push(lastShot.time, lastShot.power);
                    //});
                    let i = 0;
                    const lengthg = data.guns.length;
                    for (; i < lengthg; i++) {
                        gundata.push(data.guns[i].time, data.guns[i].power);
                    }
                    output.push(...gundata);
                    // For each turret, add their own output
                    let turdata = [data.turrets.length];
                    let j = 0;
                    const lengtht = data.turrets.length;
                    for (; j < lengtht; j++) {
                        turdata.push(...flatten(data.turrets[j]));
                    }
                    //data.turrets.forEach(turret => { turdata.push(...flatten(turret)); });
                    // Push all that to the array
                    output.push(...turdata);
                    // Return it
                    return output;
                }
                function perspective(e, player, data) {
                    if (player.body != null) {
                        if (player.body.id === e.master.id) {
                            data = data.slice(); // So we don't mess up references to the original
                            // Set the proper color if it's on our team
                            // And make it force to our mouse if it ought to
                            if (player.command.autospin) {
                                data[10] = 1;
                            }
                        }
                    }
                    return data;
                }
                function check(camera, obj) {
                    return Math.abs(obj.x - camera.x) < camera.fov * 0.6 + 1.5 * obj.size + 100 && Math.abs(obj.y - camera.y) < camera.fov * 0.6 * 0.5625 + 1.5 * obj.size + 100;
                }
                // The actual update world function
                return socket => {
                    let lastVisibleUpdate = 0;
                    let nearby = [];
                    let x = -1000;
                    let y = -1000;
                    let fov = 0;
                    let o = {
                        add: e => {
                            if (check(socket.camera, e)) nearby.push(e);
                        },
                        remove: e => {
                            let i = nearby.indexOf(e);if (i !== -1) util.remove(nearby, i);
                        },
                        check: (e, f) => {
                            return check(socket.camera, e);
                        }, //Math.abs(e.x - x) < e.size + f*fov && Math.abs(e.y - y) < e.size + f*fov; },
                        gazeUpon: () => {
                            logs.network.set();
                            let player = socket.player,
                                camera = socket.camera;
                            // If nothing has changed since the last update, wait (approximately) until then to update
                            let rightNow = room.lastCycle;
                            if (rightNow === camera.lastUpdate) {
                                socket.update(5 + room.cycleSpeed - util.time() + rightNow);
                                return 1;
                            }
                            // ...elseeeeee...
                            // Update the record.
                            camera.lastUpdate = rightNow;
                            // Get the socket status
                            socket.status.receiving++;
                            // Now prepare the data to emit
                            let setFov = camera.fov;
                            // If we are alive, update the camera
                            if (player.body != null) {
                                // But I just died...
                                if (player.body.isDead()) {
                                    socket.status.deceased = true;
                                    // Let the client know it died
                                    socket.talk('F', ...player.records());
                                    // Remove the body
                                    player.body = null;
                                }
                                // I live!
                                else if (player.body.photo) {
                                        // Update camera position and motion
                                        camera.x = player.body.photo.x;
                                        camera.y = player.body.photo.y;
                                        camera.vx = player.body.photo.vx;
                                        camera.vy = player.body.photo.vy;
                                        // Get what we should be able to see
                                        setFov = player.body.fov;
                                        // Get our body id
                                        player.viewId = player.body.id;
                                    }
                            }
                            if (player.body == null) {
                                // u dead bro
                                setFov = 2000;
                            }
                            // Smoothly transition view size
                            camera.fov += Math.max((setFov - camera.fov) / 30, setFov - camera.fov);
                            // Update my stuff
                            x = camera.x;y = camera.y;fov = camera.fov;
                            // Find what the user can see.
                            // Update which entities are nearby
                            if (camera.lastUpdate - lastVisibleUpdate > c.visibleListInterval) {
                                // Update our timer
                                lastVisibleUpdate = camera.lastUpdate;
                                // And update the nearby list
                                nearby = entities.map(e => {
                                    if (check(socket.camera, e)) return e;
                                }).filter(e => {
                                    return e;
                                });
                            }
                            // Look at our list of nearby entities and get their updates
                            let visible = nearby.map(function mapthevisiblerealm(e) {
                                if (e.photo) {
                                    if (Math.abs(e.x - x) < fov / 2 + 1.5 * e.size && Math.abs(e.y - y) < fov / 2 * (9 / 16) + 1.5 * e.size) {
                                        // Grab the photo
                                        if (!e.flattenedPhoto) e.flattenedPhoto = flatten(e.photo);
                                        return perspective(e, player, e.flattenedPhoto);
                                    }
                                }
                            }).filter(e => {
                                return e;
                            });
                            // Spread it for upload
                            let numberInView = visible.length,
                                view = [];
                            //visible.forEach(e => { view.push(...e); });
                            let i = 0;
                            const length = visible.length;
                            for (; i < length; i++) {
                                view.push(...visible[i]);
                            }
                            // Update the gui
                            player.gui.update();
                            // Send it to the player
                            socket.talk('u', rightNow, camera.x, camera.y, setFov, camera.vx, camera.vy, ...player.gui.publish(), numberInView, ...view);
                            // Queue up some for the front util.log if needed
                            if (socket.status.receiving < c.networkFrontlog) {
                                socket.update(Math.max(0, 1000 / c.networkUpdateFactor - (camera.lastDowndate - camera.lastUpdate), camera.ping / c.networkFrontlog));
                            } else {
                                socket.update(c.networkFallbackTime);
                            }
                            logs.network.mark();
                        }
                    };
                    views.push(o);
                    return o;
                };
            })();
            // Make a function that will send out minimap
            // and leaderboard updates. We'll also start
            // the mm/lb updating loop here. It runs at 1Hz
            // and also kicks inactive sockets
            const broadcast = (() => {
                // This is the public information we need for broadcasting
                let readmap, readlb;
                // Define fundamental functions
                const getminimap = (() => {
                    // Build a map cleaner
                    let cleanmapreader = (() => {
                        function flattener() {
                            let internalmap = [];
                            // Define the flattener
                            function flatten(data) {
                                // In case it's all filtered away, we'll still have something to work with
                                if (data == null) data = [];
                                let out = [data.length];
                                // Push it flat
                                //data.forEach(d => out.push(...d));
                                let i = 0;
                                let length = data.length;
                                for (; i < length; i++) {
                                    out.push(...data[i]);
                                }
                                return out;
                            }
                            // Make a test function
                            function challenge(value, challenger) {
                                return value[1] === challenger[0] && value[2] === challenger[1] && value[3] === challenger[2];
                            }
                            // Return our functions
                            return {
                                update: data => {
                                    // Flag all old data as to be removed
                                    //internalmap.forEach(e => e[0] = -1);
                                    let y = 0;
                                    const rlength = internalmap.length;
                                    for (; y < rlength; y++) {
                                        internalmap[y][0] = -1;
                                    }
                                    // Round all the old data
                                    data = data.map(d => {
                                        return [Math.round(255 * util.clamp(d[0] / room.width, 0, 1)), Math.round(255 * util.clamp(d[1] / room.height, 0, 1)), d[2]];
                                    });
                                    // Add new data and stabilze existing data, then emove old data
                                    let j = 0;
                                    const length = data.length;
                                    for (; j < length; j++) {
                                        // Find if it's already there
                                        let i = internalmap.findIndex(e => {
                                            return challenge(e, data[j]);
                                        });
                                        if (i === -1) {
                                            // if not add it
                                            internalmap.push([1, ...data[j]]);
                                        } else {
                                            // if so, flag it as stable
                                            internalmap[i][0] = 0;
                                        }
                                    }
                                    // Export all new and old data
                                    let ex = internalmap.filter(e => e[0] !== 0);
                                    // Remove outdated data
                                    internalmap = internalmap.filter(e => e[0] !== -1);
                                    // Flatten the exports
                                    let f = flatten(ex);
                                    return f;
                                },
                                exportall: () => {
                                    // Returns a flattened version of the map with blanket add requests
                                    return flatten(internalmap.map(e => {
                                        return [1, e[1], e[2], e[3]];
                                    }));
                                }
                            };
                        }
                        // Define the function
                        return room.gameMode === 'ffa' ?
                        // ffa function builder
                        (() => {
                            // Make flatteners
                            let publicmap = flattener();
                            // Return the function
                            return () => {
                                // Updates
                                let clean = publicmap.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' ? entry[3] : 17];
                                }));
                                let full = publicmap.exportall();
                                // Reader
                                return (team, everything = false) => {
                                    return everything ? full : clean;
                                };
                            };
                        })() :
                        // tdm function builder
                        (() => {
                            // Make flatteners
                            let team1map = flattener();
                            let team2map = flattener();
                            let team3map = flattener();
                            let team4map = flattener();
                            let team5map = flattener();
                            let team6map = flattener();
                            // Return the function
                            return () => {
                                let clean = [team1map.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' || entry[4] === 'tank' && entry[5] === -1 ? entry[3] : 17];
                                })), team2map.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' || entry[4] === 'tank' && entry[5] === -2 ? entry[3] : 17];
                                })), team3map.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' || entry[4] === 'tank' && entry[5] === -3 ? entry[3] : 17];
                                })), team4map.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' || entry[4] === 'tank' && entry[5] === -4 ? entry[3] : 17];
                                })), team5map.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' || entry[4] === 'tank' && entry[5] === -4 ? entry[3] : 17];
                                })), team6map.update(minimap.map(function (entry) {
                                    return [entry[1], entry[2], entry[4] === 'miniboss' || entry[4] === 'tank' && entry[5] === -4 ? entry[3] : 17];
                                }))];
                                let full = [team1map.exportall(), team2map.exportall(), team3map.exportall(), team4map.exportall(), team5map.exportall(), team6map.exportall()];
                                // The reader
                                return (team, everything = false) => {
                                    return everything ? full[team - 1] : clean[team - 1];
                                };
                            };
                        })();
                    })();
                    // Return the builder function. This itself returns
                    // a reader for the map (will change based on team)
                    return () => {
                        // Update the minimap
                        let i = 0;
                        const length = entities.length;
                        for (; i < length; i++) {
                            let my = entities[i];
                            if (my.settings.drawShape && ran.dice(my.stealth * c.STEALTH)) {
                                let i = minimap.findIndex(entry => {
                                    return entry[0] === my.id;
                                });
                                if (i != -1) {
                                    // update position
                                    minimap[i] = [my.id, my.x, my.y, my.color, my.type, my.team];
                                } else {
                                    // add position
                                    minimap.push([my.id, my.x, my.y, my.color, my.type, my.team]);
                                }
                            }
                        }
                        // Clean the map and return the reader
                        return cleanmapreader();
                    };
                })();
                const getleaderboard = (() => {
                    let lb = { full: [], updates: [] };
                    // We'll reuse these lists over and over again
                    let list = new goog.structs.PriorityQueue();
                    // This puts things in the data structure
                    function listify(instance) {
                        if (instance.settings.leaderboardable && instance.settings.drawShape && (instance.type === 'tank' || instance.killCount.solo || instance.killCount.assists)) {
                            list.enqueue(1 / (instance.skill.score + 1), instance);
                        }
                    }
                    // Build a function to prepare for export
                    let flatten = (() => {
                        let leaderboard = {};
                        // Define our index manager
                        let indices = (() => {
                            let data = [],
                                removed = [];
                            // Provide the index manager methods
                            return {
                                flag: () => {
                                    //data.forEach(index => {
                                    //    index.status = -1;
                                    //});
                                    let i = 0;
                                    const length = data.length;
                                    for (; i < length; i++) {
                                        data[i].status = -1;
                                    }
                                    if (data == null) {
                                        data = [];
                                    }
                                },
                                cull: () => {
                                    removed = [];
                                    data = data.filter(index => {
                                        let doit = index.status === -1;
                                        if (doit) removed.push(index.id);
                                        return !doit;
                                    });
                                    return removed;
                                },
                                add: id => {
                                    data.push({ id: id, status: 1 });
                                },
                                stabilize: id => {
                                    data[data.findIndex(index => {
                                        return index.id === id;
                                    })].status = 0;
                                }
                            };
                        })();
                        // This processes it
                        let process = (() => {
                            // A helpful thing
                            function barcolor(entry) {
                                switch (entry.team) {
                                    case -100:
                                        return entry.color;
                                    case -1:
                                        return 10;
                                    case -2:
                                        return 11;
                                    case -3:
                                        return 12;
                                    case -4:
                                        return 15;
                                    case -5:
                                        return 13;
                                    default:
                                        {
                                            if (room.gameMode === 'tdm') return entry.color;
                                            return 11;
                                        }
                                }
                            }
                            // A shared (and protected) thing
                            function getfull(entry) {
                                return [-entry.id, Math.round(entry.skill.score), entry.index, entry.name, entry.color, barcolor(entry)];
                            }
                            return {
                                normal: entry => {
                                    // Check if the entry is already there
                                    let id = entry.id,
                                        score = Math.round(entry.skill.score);
                                    let lb = leaderboard['_' + id];
                                    if (lb != null) {
                                        // Unflag it for removal
                                        indices.stabilize(id);
                                        // Figure out if we need to update anything
                                        if (lb.score !== score || lb.index !== entry.index) {
                                            // If so, update our record first
                                            lb.score = score;
                                            lb.index = entry.index;
                                            // Return it for broadcasting
                                            return [id, score, entry.index];
                                        }
                                    } else {
                                        // Record it
                                        indices.add(id);
                                        leaderboard['_' + id] = {
                                            score: score,
                                            name: entry.name,
                                            index: entry.index,
                                            color: entry.color,
                                            bar: barcolor(entry)
                                        };
                                        // Return it for broadcasting
                                        return getfull(entry);
                                    }
                                },
                                full: entry => {
                                    return getfull(entry);
                                }
                            };
                        })();
                        // The flattening functions
                        return data => {
                            // Start
                            indices.flag();
                            // Flatten the orders
                            let orders = data.map(process.normal).filter(e => {
                                return e;
                            }),
                                refresh = data.map(process.full).filter(e => {
                                return e;
                            }),
                                flatorders = [],
                                flatrefresh = [];
                            let lengtho = orders.length;
                            let lengthr = refresh.length;
                            let o = 0;
                            let r = 0;
                            for (; o < lengtho; o++) {
                                flatorders.push(...orders[o]);
                            }
                            for (; r < lengthr; r++) {
                                flatrefresh.push(...refresh[r]);
                            }
                            //rders.forEach(e => flatorders.push(...e));
                            //refresh.forEach(e => flatrefresh.push(...e));
                            // Find the stuff to remove
                            let removed = indices.cull();
                            // Make sure we sync the leaderboard
                            let i = 0;
                            const length = removed.length;
                            //for (; i < length; i++) {
                            //    delete leaderboard['_' + removed[i]];
                            //}
                            removed.forEach(id => {
                                delete leaderboard['_' + id];
                            });
                            return {
                                updates: [removed.length, ...removed, orders.length, ...flatorders],
                                full: [-1, refresh.length, ...flatrefresh] // The -1 tells the client it'll be a full refresh
                            };
                        };
                    })();
                    // The update function (returns a reader)
                    return () => {
                        list.clear();
                        // Sort everything
                        let i = 0;
                        const length = entities.length;
                        for (; i < length; i++) {
                            listify(entities[i]);
                        }
                        //entities.forEach(listify);
                        // Get the top ten
                        let topTen = [];
                        for (let i = 0; i < 10; i++) {
                            // Only if there's anything in the list of course
                            if (list.getCount()) {
                                topTen.push(list.dequeue());
                            } else {
                                break;
                            }
                        }
                        topTen = topTen.filter(e => {
                            return e;
                        });
                        room.topPlayerID = topTen.length ? topTen[0].id : -1;
                        // Remove empty values and process it
                        lb = flatten(topTen);
                        // Return the reader
                        return (full = false) => {
                            return full ? lb.full : lb.updates;
                        };
                    };
                })();
                // Define a 1 Hz update loop
                function slowloop() {
                    // Build the minimap
                    logs.minimap.set();
                    readmap = getminimap();
                    // Build the leaderboard
                    readlb = getleaderboard();
                    logs.minimap.mark();
                    // Check sockets
                    let time = util.time();
                    for (let socket of clients) {
                        if (socket.timeout.check(time)) socket.kick('Kicked for inactivity.');
                        if (time - socket.statuslastHeartbeat > c.maxHeartbeatInterval) socket.kick('Lost heartbeat.');
                    }
                }
                // Start it
                slowloop();
                setInterval(slowloop, 1000);
                // Give the broadcast method
                return socket => {
                    // Make sure it's spawned first
                    if (socket.status.hasSpawned) {
                        let m = [0],
                            lb = [0, 0];
                        m = readmap(socket.player.team, socket.status.needsFullMap);
                        socket.status.needsFullMap = false;
                        lb = readlb(socket.status.needsFullLeaderboard);
                        socket.status.needsFullLeaderboard = false;
                        // Don't broadcast if you don't need to
                        if (m !== [0] || lb !== [0, 0]) {
                            socket.talk('b', ...m, ...lb);
                        }
                    }
                };
            })();
            // Build the returned function
            // This function initalizes the socket upon connection
            return (socket, req) => {
                // Get information about the new connection and verify it
                if (c.servesStatic || req.connection.remoteAddress === '::ffff:127.0.0.1' || req.connection.remoteAddress === '::1') {
                    socket.ip = req.headers['x-forwarded-for'];
                    // Make sure we're not banned...
                    if (bannedIPs.findIndex(ip => {
                        return ip === socket.ip;
                    }) !== -1) {
                        socket.terminate();
                        return 1;
                    }
                    // Make sure we're not already connected...
                    if (!c.servesStatic) {
                        let n = connectedIPs.findIndex(w => {
                            return w.ip === socket.ip;
                        });
                        if (n !== -1) {
                            // Don't allow more than 2
                            if (connectedIPs[n].number > 1) {
                                util.warn('Too many connections from the same IP. [' + socket.ip + ']');
                                socket.terminate();
                                return 1;
                            } else connectedIPs[n].number++;
                        } else connectedIPs.push({ ip: socket.ip, number: 1 });
                    }
                } else {
                    // Don't let banned IPs connect.
                    util.warn(req.connection.remoteAddress);
                    util.warn(req.headers['x-forwarded-for']);
                    socket.terminate();
                    util.warn('Inappropiate connection request: header spoofing. Socket terminated.');
                    return 1;
                }
                util.log(socket.ip + ' is trying to connect...');
                // Set it up
                socket.binaryType = 'arraybuffer';
                socket.key = '';
                socket.player = { camera: {} };
                socket.timeout = (() => {
                    let mem = 0;
                    let timer = 0;
                    return {
                        set: val => {
                            if (mem !== val) {
                                mem = val;timer = util.time();
                            }
                        },
                        check: time => {
                            return timer && time - timer > c.maxHeartbeatInterval;
                        }
                    };
                })();
                // Set up the status container
                socket.status = {
                    verified: false,
                    receiving: 0,
                    deceased: true,
                    requests: 0,
                    hasSpawned: false,
                    needsFullMap: true,
                    needsFullLeaderboard: true,
                    lastHeartbeat: util.time()
                };
                // Set up loops
                socket.loops = (() => {
                    let nextUpdateCall = null; // has to be started manually
                    let trafficMonitoring = setInterval(() => traffic(socket), 1000);
                    let broadcastingGuiStuff = setInterval(() => broadcast(socket), 1500);
                    // Return the loop methods
                    return {
                        setUpdate: timeout => {
                            nextUpdateCall = timeout;
                        },
                        cancelUpdate: () => {
                            clearTimeout(nextUpdateCall);
                        },
                        terminate: () => {
                            clearTimeout(nextUpdateCall);
                            clearTimeout(trafficMonitoring);
                            clearTimeout(broadcastingGuiStuff);
                        }
                    };
                })();
                // Set up the camera
                socket.camera = {
                    x: undefined,
                    y: undefined,
                    vx: 0,
                    vy: 0,
                    lastUpdate: util.time(),
                    lastDowndate: undefined,
                    fov: 2000
                };
                // Set up the viewer
                socket.makeView = () => {
                    socket.view = eyes(socket);
                };
                socket.makeView();
                // Put the fundamental functions in the socket
                socket.ban = () => ban(socket);
                socket.kick = reason => kick(socket, reason);
                socket.talk = (...message) => {
                    if (socket.readyState === socket.OPEN) {
                        socket.send(protocol.encode(message), { binary: true });
                    }
                };
                socket.lastWords = (...message) => {
                    if (socket.readyState === socket.OPEN) {
                        socket.send(protocol.encode(message), { binary: true }, () => timer.setTimeout(() => socket.terminate(), '', '1000m'));
                    }
                };
                socket.on('message', message => incoming(message, socket));
                socket.on('close', () => {
                    socket.loops.terminate();close(socket);
                });
                socket.on('error', e => {
                    util.log('[ERROR]:');util.error(e);
                });
                // Put the player functions in the socket
                socket.spawn = name => {
                    return spawn(socket, name);
                };
                // And make an update
                socket.update = time => {
                    socket.loops.cancelUpdate();
                    socket.loops.setUpdate(setTimeout(() => {
                        socket.view.gazeUpon();
                    }, time.toString()));
                };
                // Log it
                clients.push(socket);
                util.log('[INFO] New socket opened with ', socket.ip);
            };
        })()
    };
})();

/**** GAME SETUP ****/
// Define how the game lives
// The most important loop. Fast looping.

var gameloop = (() => {
    // Collision stuff
    let collide = (() => {
        function simplecollide(my, n) {
            let diff = (1 + util.getDistance(my, n) / 2) * roomSpeed;
            let a = my.intangibility ? 1 : my.pushability,
                b = n.intangibility ? 1 : n.pushability,
                c = 0.05 * (my.x - n.x) / diff,
                d = 0.05 * (my.y - n.y) / diff;
            my.accel.x += a / (b + 0.3) * c;
            my.accel.y += a / (b + 0.3) * d;
            n.accel.x -= b / (a + 0.3) * c;
            n.accel.y -= b / (a + 0.3) * d;
        }
        function firmcollide(my, n, buffer = 0) {
            let item1 = { x: my.x + my.m_x, y: my.y + my.m_y };
            let item2 = { x: n.x + n.m_x, y: n.y + n.m_y };
            let dist = util.getDistance(item1, item2);
            let s1 = Math.max(my.velocity.length, my.topSpeed);
            let s2 = Math.max(n.velocity.length, n.topSpeed);
            let strike1, strike2;
            if (buffer > 0 && dist <= my.realSize + n.realSize + buffer) {
                let repel = (my.acceleration + n.acceleration) * (my.realSize + n.realSize + buffer - dist) / buffer / roomSpeed;
                my.accel.x += repel * (item1.x - item2.x) / dist * 1.525;
                my.accel.y += repel * (item1.y - item2.y) / dist * 1.525;
                n.accel.x -= repel * (item1.x - item2.x) / dist * 1.525;
                n.accel.y -= repel * (item1.y - item2.y) / dist * 1.525;
            }
            while (dist <= my.realSize + n.realSize && !(strike1 && strike2)) {
                strike1 = false;strike2 = false;
                if (my.velocity.length <= s1) {
                    my.velocity.x -= 0.05 * (item2.x - item1.x) / dist / roomSpeed;
                    my.velocity.y -= 0.05 * (item2.y - item1.y) / dist / roomSpeed;
                } else {
                    strike1 = true;
                }
                if (n.velocity.length <= s2) {
                    n.velocity.x += 0.05 * (item2.x - item1.x) / dist / roomSpeed;
                    n.velocity.y += 0.05 * (item2.y - item1.y) / dist / roomSpeed;
                } else {
                    strike2 = true;
                }
                item1 = { x: my.x + my.m_x, y: my.y + my.m_y };
                item2 = { x: n.x + n.m_x, y: n.y + n.m_y };
                dist = util.getDistance(item1, item2);
            }
        }
        function reflectcollide(wall, bounce) {
            let delt = new Vector(wall.x - bounce.x, wall.y - bounce.y);
            let dist = delt.length;
            let diff = wall.size + bounce.size - dist;
            if (diff > 0) {
                bounce.accel.x -= diff * delt.x / dist * 1.525;
                bounce.accel.y -= diff * delt.y / dist * 1.525;
                return 1;
            }
            return 0;
        }
        function advancedcollide(my, n, doDamage, doInelastic, nIsFirmCollide = false) {
            // Prepare to check
            let tock = Math.min(my.stepRemaining, n.stepRemaining),
                combinedRadius = n.size + my.size,
                motion = {
                _me: new Vector(my.m_x, my.m_y),
                _n: new Vector(n.m_x, n.m_y)
            },
                delt = new Vector(tock * (motion._me.x - motion._n.x), tock * (motion._me.y - motion._n.y)),
                diff = new Vector(my.x - n.x, my.y - n.y),
                dir = new Vector((n.x - my.x) / diff.length, (n.y - my.y) / diff.length),
                component = Math.max(0, dir.x * delt.x + dir.y * delt.y);

            if (n.customshapes !== undefined) {
                if (n.customshapes.length > 0) {
                    let centerX = n.x;
                    let centerY = n.y;
                    let points = [];
                    let edgevaluesx = [];
                    let edgevaluesy = [];
                    for (let point in n.customshapes) {
                        points.push(point);
                    }
                    for (let i = 0; i < points.length; i++) {
                        let xDifference;
                        let yDifference;
                        if (i + 1 <= points.length) {
                            xDifference = Math.abs(points[i][0] - points[i + 1][0]);
                            yDifference = Math.abs(points[i][1] - points[i + 1][1]);
                            let changeX = 1;
                            let changeY = 1;
                            if (points[i + 1][0] < points[i][0]) {
                                changeX = -1;
                            }
                            if (points[i + 1][1] < points[i][1]) {
                                changeY = -1;
                            }
                            for (let i = 0; i < xDifference; i++) {
                                edgevaluesx.push(points[i][0] + i * changeX);
                            }
                            for (let j = 0; i < yDifference; j++) {
                                edgevaluesy.push(points[j][0] + j * changeY);
                            }
                        }
                    }
                }
            }

            if (component >= diff.length - combinedRadius) {
                // A simple check
                // A more complex check
                let goahead = false,
                    tmin = 1 - tock,
                    tmax = 1,
                    A = Math.pow(delt.x, 2) + Math.pow(delt.y, 2),
                    B = 2 * delt.x * diff.x + 2 * delt.y * diff.y,
                    C = Math.pow(diff.x, 2) + Math.pow(diff.y, 2) - Math.pow(combinedRadius, 2),
                    det = B * B - 4 * A * C,
                    t;

                if (!A || det < 0 || C < 0) {
                    // This shall catch mathematical errors
                    t = 0;
                    if (C < 0) {
                        // We have already hit without moving
                        goahead = true;
                    }
                } else {
                    let t1 = (-B - Math.sqrt(det)) / (2 * A),
                        t2 = (-B + Math.sqrt(det)) / (2 * A);
                    if (t1 < tmin || t1 > tmax) {
                        // 1 is out of range
                        if (t2 < tmin || t2 > tmax) {
                            // 2 is out of range;
                            t = false;
                        } else {
                            // 1 is out of range but 2 isn't
                            t = t2;goahead = true;
                        }
                    } else {
                        // 1 is in range
                        if (t2 >= tmin && t2 <= tmax) {
                            // They're both in range!
                            t = Math.min(t1, t2);goahead = true; // That means it passed in and then out again.  Let's use when it's going in
                        } else {
                            // Only 1 is in range
                            t = t1;goahead = true;
                        }
                    }
                }
                if (goahead) {
                    // Add to record
                    my.collisionArray.push(n);
                    n.collisionArray.push(my);
                    if (t) {
                        // Only if we still need to find the collision
                        // Step to where the collision occured
                        my.x += motion._me.x * t;
                        my.y += motion._me.y * t;
                        n.x += motion._n.x * t;
                        n.y += motion._n.y * t;

                        my.stepRemaining -= t;
                        n.stepRemaining -= t;

                        // Update things
                        diff = new Vector(my.x - n.x, my.y - n.y);
                        dir = new Vector((n.x - my.x) / diff.length, (n.y - my.y) / diff.length);
                        component = Math.max(0, dir.x * delt.x + dir.y * delt.y);
                    }
                    let componentNorm = component / delt.length;
                    // Prepare some things
                    let reductionFactor = 1,
                        deathFactor = {
                        _me: 1,
                        _n: 1
                    },
                        accelerationFactor = delt.length ? combinedRadius / 4 / (Math.floor(combinedRadius / delt.length) + 1) : 0.001,
                        depth = {
                        _me: util.clamp((combinedRadius - diff.length) / (2 * my.size), 0, 1), //1: I am totally within it
                        _n: util.clamp((combinedRadius - diff.length) / (2 * n.size), 0, 1) //1: It is totally within me
                    },
                        combinedDepth = {
                        up: depth._me * depth._n,
                        down: (1 - depth._me) * (1 - depth._n)
                    },
                        pen = {
                        _me: {
                            sqr: Math.pow(my.penetration, 2),
                            sqrt: Math.sqrt(my.penetration)
                        },
                        _n: {
                            sqr: Math.pow(n.penetration, 2),
                            sqrt: Math.sqrt(n.penetration)
                        }
                    },
                        savedHealthRatio = {
                        _me: my.health.ratio,
                        _n: n.health.ratio
                    };
                    if (doDamage) {
                        let speedFactor = { // Avoid NaNs and infinities
                            _me: my.maxSpeed ? Math.pow(motion._me.length / my.maxSpeed, 0.25) : 1,
                            _n: n.maxSpeed ? Math.pow(motion._n.length / n.maxSpeed, 0.25) : 1
                        };

                        let bail = false;
                        if (my.shape === n.shape && my.settings.isNecromancer && n.type === 'food') {
                            //bail = my.necro(n);
                        } else if (my.shape === n.shape && n.settings.isNecromancer && my.type === 'food') {
                            //bail = n.necro(my);
                        }
                        if (!bail) {
                            // Calculate base damage
                            let resistDiff = my.health.resist - n.health.resist,
                                damage = {
                                _me: c.DAMAGE_CONSTANT * my.damage * (1 + resistDiff) * (1 + n.heteroMultiplier * (my.settings.damageClass === n.settings.damageClass)) * (my.settings.buffVsFood && n.settings.damageType === 1 ? 3 : 1) * my.damageMultiplier() * Math.min(2, Math.max(speedFactor._me, 1) * speedFactor._me),
                                _n: c.DAMAGE_CONSTANT * n.damage * (1 - resistDiff) * (1 + my.heteroMultiplier * (my.settings.damageClass === n.settings.damageClass)) * (n.settings.buffVsFood && my.settings.damageType === 1 ? 3 : 1) * n.damageMultiplier() * Math.min(2, Math.max(speedFactor._n, 1) * speedFactor._n)
                            };
                            // Advanced damage calculations
                            if (my.settings.ratioEffects) {
                                damage._me *= Math.min(1, Math.pow(Math.max(my.health.ratio, my.shield.ratio), 1 / my.penetration));
                            }
                            if (n.settings.ratioEffects) {
                                damage._n *= Math.min(1, Math.pow(Math.max(n.health.ratio, n.shield.ratio), 1 / n.penetration));
                            }
                            if (my.settings.damageEffects) {
                                damage._me *= accelerationFactor * (1 + (componentNorm - 1) * (1 - depth._n) / my.penetration) * (1 + pen._n.sqrt * depth._n - depth._n) / pen._n.sqrt;
                            }
                            if (n.settings.damageEffects) {
                                damage._n *= accelerationFactor * (1 + (componentNorm - 1) * (1 - depth._me) / n.penetration) * (1 + pen._me.sqrt * depth._me - depth._me) / pen._me.sqrt;
                            }
                            // Find out if you'll die in this cycle, and if so how much damage you are able to do to the other target
                            let damageToApply = {
                                _me: damage._me,
                                _n: damage._n
                            };
                            if (n.shield.max) {
                                damageToApply._me -= n.shield.getDamage(damageToApply._me);
                            }
                            if (my.shield.max) {
                                damageToApply._n -= my.shield.getDamage(damageToApply._n);
                            }
                            let stuff = my.health.getDamage(damageToApply._n, false);
                            deathFactor._me = stuff > my.health.amount ? my.health.amount / stuff : 1;
                            stuff = n.health.getDamage(damageToApply._me, false);
                            deathFactor._n = stuff > n.health.amount ? n.health.amount / stuff : 1;

                            reductionFactor = Math.min(deathFactor._me, deathFactor._n);

                            // Now apply it
                            my.damageRecieved += damage._n * deathFactor._n;
                            n.damageRecieved += damage._me * deathFactor._me;
                        }
                    }
                    /*************   POISON  ***********/
                    if (n.poison) {
                        my.poisoned = true;
                        my.poisonedLevel = n.poisionToApply;
                        my.poisonTime = 20;
                        my.poisonedBy = n.master;
                    }
                    if (my.poison) {
                        n.poisoned = true;
                        n.poisonedLevel = my.poisionToApply;
                        n.poisonTime = 20;
                        n.poisonedBy = my.master;
                    }
                    if (n.breakarmor) {
                        my.armorbroken = true;
                    }
                    if (my.breakarmor) {
                        n.armorbroken = true;
                    }
                    /*************   DO MOTION  ***********/
                    if (nIsFirmCollide < 0) {
                        nIsFirmCollide *= -0.5;
                        my.accel.x -= nIsFirmCollide * component * dir.x;
                        my.accel.y -= nIsFirmCollide * component * dir.y;
                        n.accel.x += nIsFirmCollide * component * dir.x;
                        n.accel.y += nIsFirmCollide * component * dir.y;
                    } else if (nIsFirmCollide > 0) {
                        n.accel.x += nIsFirmCollide * (component * dir.x + combinedDepth.up);
                        n.accel.y += nIsFirmCollide * (component * dir.y + combinedDepth.up);
                    } else {
                        // Calculate the impulse of the collision
                        let elasticity = 2 - 4 * Math.atan(my.penetration * n.penetration) / Math.PI;
                        if (doInelastic && my.settings.motionEffects && n.settings.motionEffects) {
                            elasticity *= savedHealthRatio._me / pen._me.sqrt + savedHealthRatio._n / pen._n.sqrt;
                        } else {
                            elasticity *= 2;
                        }
                        let spring = 2 * Math.sqrt(savedHealthRatio._me * savedHealthRatio._n) / roomSpeed,
                            elasticImpulse = Math.pow(combinedDepth.down, 2) * elasticity * component * my.mass * n.mass / (my.mass + n.mass),
                            springImpulse = c.KNOCKBACK_CONSTANT * spring * combinedDepth.up,
                            impulse = -(elasticImpulse + springImpulse) * (1 - my.intangibility) * (1 - n.intangibility),
                            force = {
                            x: impulse * dir.x,
                            y: impulse * dir.y
                        },
                            modifiers = {
                            _me: c.KNOCKBACK_CONSTANT * my.pushability / my.mass * deathFactor._n,
                            _n: c.KNOCKBACK_CONSTANT * n.pushability / n.mass * deathFactor._me
                        };
                        // Apply impulse as force
                        my.accel.x += modifiers._me * force.x * 1.6;
                        my.accel.y += modifiers._me * force.y * 1.6;
                        n.accel.x -= modifiers._n * force.x * 1.6;
                        n.accel.y -= modifiers._n * force.y * 1.6;
                    }
                }
            }
        }
        // The actual collision resolution function
        return collision => {
            // Pull the two objects from the collision grid
            let instance = collision[0],
                other = collision[1];
            // Check for ghosts...
            if (other.isGhost) {
                util.error('GHOST FOUND');
                util.error(other.label);
                util.error('x: ' + other.x + ' y: ' + other.y);
                util.error(other.collisionArray);
                util.error('health: ' + other.health.amount);
                util.warn('Ghost removed.');
                if (grid.checkIfInHSHG(other)) {
                    util.warn('Ghost removed.');grid.removeObject(other);
                }
                return 0;
            }
            if (instance.isGhost) {
                util.error('GHOST FOUND');
                util.error(instance.label);
                util.error('x: ' + instance.x + ' y: ' + instance.y);
                util.error(instance.collisionArray);
                util.error('health: ' + instance.health.amount);
                if (grid.checkIfInHSHG(instance)) {
                    util.warn('Ghost removed.');grid.removeObject(instance);
                }
                return 0;
            }
            let delt = new Vector(instance.x - other.x, instance.y - other.y);
            let dist = delt.length;
            let diff = instance.size + other.size - dist;

            if (diff > 0) {
                if (!instance.activation.check() && !other.activation.check()) {
                    util.warn('Tried to collide with an inactive instance.');return 0;
                }
                // Handle walls
                if (instance.type === 'wall' || other.type === 'wall') {
                    let a = instance.type === 'bullet' || other.type === 'bullet' ? 1 + 10 / (Math.max(instance.velocity.length, other.velocity.length) + 10) : 1;
                    if (instance.type === 'wall') advancedcollide(instance, other, false, false, a);else advancedcollide(other, instance, false, false, a);
                } else
                    // If they can firm collide, do that
                    if (instance.type === 'crasher' && other.type === 'food' || other.type === 'crasher' && instance.type === 'food') {
                        firmcollide(instance, other);
                    } else
                        // Otherwise, collide normally if they're from different teams
                        if (instance.team !== other.team) {
                            advancedcollide(instance, other, true, true);
                        } else
                            // Ignore them if either has asked to be
                            if (instance.settings.hitsOwnType == 'never' || other.settings.hitsOwnType == 'never') {
                                // Do jack
                            } else
                                // Standard collision resolution
                                if (instance.settings.hitsOwnType === other.settings.hitsOwnType) {
                                    switch (instance.settings.hitsOwnType) {
                                        case 'push':
                                            advancedcollide(instance, other, false, false);break;
                                        case 'hard':
                                            firmcollide(instance, other);break;
                                        case 'hardWithBuffer':
                                            firmcollide(instance, other, 30);break;
                                        case 'repel':
                                            simplecollide(instance, other);break;
                                    }
                                }
            }
        };
    })();
    // Living stuff
    function entitiesactivationloop(my) {
        // Update collisions.
        my.collisionArray = [];
        // Activation
        my.activation.update();
        my.updateAABB(my.activation.check());
    }
    function entitiesliveloop(my) {
        // Consider death.
        if (my.contemplationOfMortality()) my.destroy();else {
            if (my.bond == null) {
                // Resolve the physical behavior from the last collision cycle.
                logs.physics.set();
                my.physics();
                logs.physics.mark();
            }
            if (my.activation.check()) {
                logs.entities.tally();
                // Think about my actions.
                logs.life.set();
                my.life();
                logs.life.mark();
                // Apply friction.
                my.friction();
                my.confinementToTheseEarthlyShackles();
                logs.selfie.set();
                my.takeSelfie();
                logs.selfie.mark();
            }
        }
        // Update collisions.
        my.collisionArray = [];
    }
    let time;
    // Return the loop function
    return () => {
        //let curTime = now();
        //timestep = 0.007875 * (curTime - lastTime);
        //if (timestep <= 0 || timestep > 7.875) {
        //    timestep = 0.007875;
        //}
        logs.loops.tally();
        logs.master.set();
        logs.activation.set();
        for (var e of entities) {
            entitiesactivationloop(e);
        }
        //entities.forEach(e => entitiesactivationloop(e));
        logs.activation.mark();
        // Do collisions
        logs.collide.set();

        if (entities.length > 1) {
            // Load the grid
            grid.update();
            for (let collision of grid.queryForCollisionPairs()) {
                collide(collision);
            }
            //grid.queryForCollisionPairs().forEach(collision => collide(collision));
        }
        logs.collide.mark();
        // Do entities life
        logs.entities.set();
        for (var e of entities) {
            entitiesliveloop(e);
        }
        logs.entities.mark();
        logs.master.mark();
        // Remove dead entities
        purgeEntities();
        room.lastCycle = util.time();
        //lastTime = curTime;
    };
    //let expected = 1000 / c.gameSpeed / 30;
    //let alphaFactor = (delta > expected) ? expected / delta : 1;
    //roomSpeed = c.gameSpeed * alphaFactor;
    //setTimeout(moveloop, 1000 / roomSpeed / 30 - delta);
})();
var funloop = (() => {
    // Fun stuff, like RAINBOWS :D
    function rainbow(my) {
        let rainbow = [12, 2, 3, 11, 10, 14];
        entities.forEach(function (element) {
            if (element.rainbow) {
                if (rainbow.indexOf(element.color) == -1 || element.color == undefined) {
                    element.color = 12;
                } else {
                    if (element.rainbow_back == false) {
                        element.color = rainbow[rainbow.indexOf(element.color) + 1];
                    } else {
                        element.color = rainbow[rainbow.indexOf(element.color) - 1];
                    }
                }
                if (element.color == 14) {
                    element.rainbow_back = true;
                }
                if (element.color == 12) {
                    element.rainbow_back = false;
                }
            }
        });
    }
    return () => {
        // run the fun stuff :P
        rainbow();
    };
})();
// A less important loop. Runs at an actual 5Hz regardless of game speed.
var poisonLoop = (() => {
    // Fun stuff, like RAINBOWS :D
    function poison(my) {
        entities.forEach(function (element) {
            if (element.showpoison) {
                let x = element.size + 10;
                let y = element.size + 10;
                Math.random() < 0.5 ? x *= -1 : x;
                Math.random() < 0.5 ? y *= -1 : y;
                Math.random() < 0.5 ? x *= Math.random() + 1 : x;
                Math.random() < 0.5 ? y *= Math.random() + 1 : y;
                var o = new Entity({
                    x: element.x + x,
                    y: element.y + y
                });
                o.define(Class['poisonEffect']);
            }
            if (element.poisoned && (element.type == 'tank' || element.type == 'crasher' || element.type == 'food' || element.type == 'minion' || element.type == 'drone' || element.type == 'swarm')) {
                let x = element.size + 10;
                let y = element.size + 10;
                Math.random() < 0.5 ? x *= -1 : x;
                Math.random() < 0.5 ? y *= -1 : y;
                Math.random() < 0.5 ? x *= Math.random() + 1 : x;
                Math.random() < 0.5 ? y *= Math.random() + 1 : y;
                var o = new Entity({
                    x: element.x + x,
                    y: element.y + y
                });
                o.define(Class['poisonEffect']);

                if (!element.invuln) {
                    element.health.amount -= element.health.max / (45 - element.poisonLevel);
                    element.shield.amount -= element.shield.max / (10 - element.poisonLevel);
                }

                element.poisonTime -= 1;
                if (element.poisonTime <= 0) element.poisoned = false;

                if (element.health.amount <= 0 && element.poisonedBy != undefined && element.poisonedBy.skill != undefined) {
                    element.poisonedBy.skill.score += Math.ceil(util.getJackpot(element.poisonedBy.skill.score));
                    element.poisonedBy.sendMessage('You killed ' + element.name + ' with poison.');
                    if (element.poisonedBy.name != null) {
                        element.sendMessage('You have been killed by ' + element.poisonedBy.name + ' with poison.');
                    } else if (element.poisonedBy.name == null) {
                        element.sendMessage('You have been killed with poison.');
                    }
                }
            }
        });
    }
    return () => {
        // run the poison
        poison();
    };
})();
var maintainloop = (() => {
    // Place obstacles
    function placeRoids() {
        function placeRoid(type, entityClass) {
            let x = 0;
            let position;
            do {
                position = room.randomType(type);
                x++;
                if (x > 200) {
                    util.warn("Could not place some roids.");return 0;
                }
            } while (dirtyCheck(position, 10 + entityClass.SIZE));
            let o = new Entity(position);
            o.define(entityClass);
            o.team = -101;
            o.facing = ran.randomAngle();
            o.protect();
            o.life();
        }
        // Start placing them
        let roidcount = room.roid.length * room.width * room.height / room.xgrid / room.ygrid / 50000 / 1.5;
        let rockcount = room.rock.length * room.width * room.height / room.xgrid / room.ygrid / 250000 / 1.5;
        let count = 0;
        for (let i = Math.ceil(roidcount); i; i--) {
            count++;placeRoid('roid', ran.choose([Class.obstacle, Class.obstacle, Class.obstacle, Class.obstacle, Class.autoroid]));
        }
        for (let i = Math.ceil(roidcount * 0.3); i; i--) {
            count++;placeRoid('roid', ran.choose([Class.babyObstacle, Class.babyObstacle, Class.babyObstacle, Class.babyObstacle, Class.autorock]));
        }
        for (let i = Math.ceil(rockcount); i; i--) {
            count++;placeRoid('rock', ran.choose([Class.obstacle, Class.obstacle, Class.obstacle, Class.obstacle, Class.autoroid]));
        }
        for (let i = Math.ceil(rockcount * 0.3); i; i--) {
            count++;placeRoid('rock', ran.choose([Class.babyObstacle, Class.babyObstacle, Class.babyObstacle, Class.babyObstacle, Class.autorock, Class.autosquare]));
        }
        util.log('Placing ' + count + ' obstacles!');
    }
    placeRoids();
    // Spawning functions
    let spawnBosses = (() => {
        let timer = 0;
        let boss = (() => {
            let i = 0,
                names = [],
                bois = [Class.egg],
                n = 0,
                begin = 'yo some shit is about to move to a lower position',
                arrival = 'Something happened lol u should probably let Neph know this broke',
                loc = 'norm';
            let spawn = () => {
                let spot,
                    m = 0;
                do {
                    spot = room.randomType(loc);m++;
                } while (dirtyCheck(spot, 500) && m < 30);
                let o = new Entity(spot);
                o.define(ran.choose(bois));
                o.team = -100;
                o.name = names[i++];
            };
            return {
                prepareToSpawn: (classArray, number, nameClass, typeOfLocation = 'norm') => {
                    n = number;
                    bois = classArray;
                    loc = typeOfLocation;
                    names = ran.chooseBossName(nameClass, number);
                    i = 0;
                    if (n === 1) {
                        begin = 'A visitor is coming.';
                        arrival = names[0] + ' has arrived.';
                    } else {
                        begin = 'Visitors are coming.';
                        arrival = '';
                        for (let i = 0; i < n - 2; i++) arrival += names[i] + ', ';
                        arrival += names[n - 2] + ' and ' + names[n - 1] + ' have arrived.';
                    }
                },
                spawn: () => {
                    sockets.broadcast(begin);
                    for (let i = 0; i < n; i++) {
                        setTimeout(spawn, ran.randomRange(3500, 5000));
                    }
                    // Wrap things up.
                    setTimeout(() => sockets.broadcast(arrival), 5000);
                    util.log('[SPAWN] ' + arrival);
                }
            };
        })();
        return census => {
            if (timer > 500 && ran.dice(510 - timer)) {
                util.log('[SPAWN] Preparing to spawn...');
                timer = 0;
                let choice = [];
                switch (ran.chooseChance(1, 1, 1, 1)) {
                    case 0:
                        choice = [[Class.palisade], 1, 'castle', 'norm'];
                        sockets.broadcast('A strange trembling...');
                        break;
                    case 1:
                        sockets.broadcast('Rifles Unite...');
                        choice = [[Class.riflespin], 2, 'castle', 'norm'];
                        break;
                    case 2:
                        choice = [[Class.extradice], 3, 'castle', 'norm'];
                        sockets.broadcast('Theres a Disturbance in the air...');
                        break;

                    case 3:
                        choice = [[Class.elitesquare], 1, 'castle', 'norm'];
                        sockets.broadcast('The Squares are fed up...');
                        break;

                }
                boss.prepareToSpawn(...choice);
                setTimeout(boss.spawn, 300);
                // Set the timeout for the spawn functions
            } else if (!census.miniboss) timer++;
        };
    })();

    let spawnCrasher = census => {
        if (ran.chance(1 - 0.8 * census.crasher / room.maxFood / room.nestFoodAmount)) {
            let spot,
                i = 30;
            do {
                spot = room.randomType('nest');i--;if (!i) return 0;
            } while (dirtyCheck(spot, 100));
            let type = ran.dice(80) ? ran.choose([Class.sentryGun, Class.sentrySwarm, Class.sentryTrap]) : Class.crasher;
            let o = new Entity(spot);
            o.define(type);
            o.team = -100;
        }
    };

    // The NPC function
    let makenpcs = (() => {
        // Make base protectors if needed.
        /*let f = (loc, team) => {
                      let o = new Entity(loc);
                          o.define(Class.baseProtector);
                          o.team = -team;
                          o.color = [10, 11, 12, 15][team-1];
                  };
                  for (let i=1; i<5; i++) {
                      room['bas' + i].forEach((loc) => { f(loc, i); });
                  }*/
        // Return the spawning function
        let bots = [];
        return () => {
            let census = {
                crasher: 0,
                miniboss: 0,
                tank: 0,
                dodecagon: 0
            };
            let npcs = entities.map(function npcCensus(instance) {
                if (census[instance.type] != null) {
                    census[instance.type]++;
                    return instance;
                }
            }).filter(e => {
                return e;
            });
            // Spawning
            //spawnCrasher(census);
            spawnBosses(census);
            // Bots
            if (bots.length < c.BOTS) {
                let o = new Entity(room.random());
                o.color = 17;
                o.define(Class.bot);
                o.define(Class.basic);
                o.name += ran.chooseBotName();
                o.refreshBodyAttributes();
                o.color = 17;
                bots.push(o);
            }
            // Remove dead ones
            bots = bots.filter(e => {
                return !e.isDead();
            });
        };
    })();
    // The big food function
    let makefood = (() => {
        let food = [],
            foodSpawners = [];
        // The two essential functions
        function getFoodClass(level) {
            let a = {};
            switch (level) {
                case 0:
                    a = Class.egg;break;
                case 1:
                    a = Class.square;break;
                case "e":
                    a = Class.wiffle;break;
                case 2:
                    a = Class.triangle;break;
                case 3:
                    a = Class.pentagon;break;
                case 4:
                    a = Class.bigPentagon;break;
                case 5:
                    a = Class.hugePentagon;break;
                case 6:
                    a = Class.megaPentagon;break;
                case "h":
                    a = Class.hexagon;break;
                case "d":
                    a = Class.dodecagon;break;
                default:
                    throw 'bad food level';
            }
            if (a !== {}) {
                a.BODY.ACCELERATION = 0.015 / (a.FOOD.LEVEL + 1);
            }
            return a;
        }
        let placeNewFood = (position, scatter, level, allowInNest = false) => {
            let o = nearest(food, position);
            let mitosis = false;
            let seed = false;
            // Find the nearest food and determine if we can do anything with it
            if (o != null) {
                for (let i = 50; i > 0; i--) {
                    if (scatter == -1 || util.getDistance(position, o) < scatter) {
                        if (ran.dice((o.foodLevel + 1) * (o.foodLevel + 1))) {
                            mitosis = true;break;
                        } else {
                            seed = true;break;
                        }
                    }
                }
            }
            // Decide what to do
            if (scatter != -1 || mitosis || seed) {
                // Splitting
                if (o != null && (mitosis || seed) && room.isIn('nest', o) === allowInNest) {
                    let levelToMake = mitosis ? o.foodLevel : level,
                        place = {
                        x: o.x + o.size * Math.cos(o.facing),
                        y: o.y + o.size * Math.sin(o.facing)
                    };
                    let new_o = new Entity(place);
                    new_o.define(getFoodClass(levelToMake));
                    new_o.team = -100;
                    new_o.facing = o.facing + ran.randomRange(Math.PI / 2, Math.PI);
                    food.push(new_o);
                    return new_o;
                }
                // Brand new
                else if (room.isIn('nest', position) === allowInNest) {
                        if (!dirtyCheck(position, 20)) {
                            o = new Entity(position);
                            o.define(getFoodClass(level));
                            o.team = -100;
                            o.facing = ran.randomAngle();
                            food.push(o);
                            return o;
                        }
                    }
            }
        };
        // Define foodspawners
        class FoodSpawner {
            constructor() {
                this.foodToMake = Math.ceil(Math.abs(ran.gauss(0, room.scale.linear * 80)));
                this.size = Math.sqrt(this.foodToMake) * 25;

                // Determine where we ought to go
                let position = {};let o;
                do {
                    position = room.gaussRing(1 / 3, 20);
                    o = placeNewFood(position, this.size, 0);
                } while (o == null);

                // Produce a few more
                for (let i = Math.ceil(Math.abs(ran.gauss(0, 4))); i <= 0; i--) {
                    placeNewFood(o, this.size, 0);
                }
                // Set location
                this.x = o.x;
                this.y = o.y;
                //util.debug('FoodSpawner placed at ('+this.x+', '+this.y+'). Set to produce '+this.foodToMake+' food.');
            }
            rot() {
                if (--this.foodToMake < 0) {
                    //util.debug('FoodSpawner rotted, respawning.');
                    util.remove(foodSpawners, foodSpawners.indexOf(this));
                    foodSpawners.push(new FoodSpawner());
                }
            }
        }
        // Add them
        foodSpawners.push(new FoodSpawner());
        foodSpawners.push(new FoodSpawner());
        foodSpawners.push(new FoodSpawner());
        foodSpawners.push(new FoodSpawner());
        // Food making functions
        let makeGroupedFood = () => {
            // Create grouped food
            // Choose a location around a spawner
            let spawner = foodSpawners[ran.irandom(foodSpawners.length - 1)],
                bubble = ran.gaussRing(spawner.size, 1 / 4);
            placeNewFood({ x: spawner.x + bubble.x, y: spawner.y + bubble.y }, -1, 0);
            spawner.rot();
        };
        let makeDistributedFood = () => {
            // Distribute food everywhere
            //util.debug('Creating new distributed food.');
            let spot = {};
            do {
                spot = room.gaussRing(1 / 2, 2);
            } while (room.isInNorm(spot));
            placeNewFood(spot, 0.01 * room.width, 0);
        };
        let makeCornerFood = () => {
            // Distribute food in the corners
            let spot = {};
            do {
                spot = room.gaussInverse(5);
            } while (room.isInNorm(spot));
            placeNewFood(spot, 0.05 * room.width, 0);
        };
        let makeNestFood = () => {
            // Make nest pentagons
            let spot = room.randomType('nest');
            placeNewFood(spot, 0.01 * room.width, 3, true);
        };
        // Return the full function
        return () => {
            // Find and understand all food
            let census = {
                [0]: 0, // Egg
                [1]: 0, // Square
                [2]: 0, // Triangle
                [3]: 0, // Penta
                [4]: 0, // Beta
                [5]: 0, // Alpha
                [6]: 0, // Gamma
                [7]: 0,
                tank: 0,
                sum: 0
            };
            let censusNest = {
                [0]: 0, // Egg
                [1]: 0, // Square
                [2]: 0, // Triangle
                [3]: 0, // Penta
                [4]: 0, // Beta
                [5]: 0, // Alpha
                [6]: 0, // Gamma
                [7]: 0,
                sum: 0
            };
            // Do the censusNest
            food = entities.map(instance => {
                try {
                    if (instance.type === 'tank') {
                        census.tank++;
                    } else if (instance.foodLevel > -1) {
                        if (room.isIn('nest', { x: instance.x, y: instance.y })) {
                            censusNest.sum++;censusNest[instance.foodLevel]++;
                        } else {
                            census.sum++;census[instance.foodLevel]++;
                        }
                        return instance;
                    }
                } catch (err) {
                    util.error(instance.label);util.error(err);instance.kill();
                }
            }).filter(e => {
                return e;
            });
            // Sum it up
            let maxFood = 1 + room.maxFood + 15 * census.tank;
            let maxNestFood = 1 + room.maxFood * room.nestFoodAmount;
            let foodAmount = census.sum;
            let nestFoodAmount = censusNest.sum;
            /*********** ROT OLD SPAWNERS **********/
            //foodSpawners.forEach(spawner => { if (ran.chance(1 - foodAmount/maxFood)) spawner.rot(); });
            let i = 0;
            const length = foodSpawners.length;
            for (; i < length; i++) {
                if (ran.chance(1 - foodAmount / maxFood)) {
                    foodSpawners[i].rot();
                }
            }
            /************** MAKE FOOD **************/
            while (ran.chance(0.8 * (1 - foodAmount * foodAmount / maxFood / maxFood))) {
                switch (ran.chooseChance(10, 2, 1)) {
                    case 0:
                        makeGroupedFood();break;
                    case 1:
                        makeDistributedFood();break;
                    case 2:
                        makeCornerFood();break;
                }
            }
            while (ran.chance(0.5 * (1 - nestFoodAmount * nestFoodAmount / maxNestFood / maxNestFood))) makeNestFood();
            /************* UPGRADE FOOD ************/
            if (!food.length) return 0;
            for (let i = Math.ceil(food.length / 100); i > 0; i--) {
                let o = food[ran.irandom(food.length - 1)],
                    // A random food instance
                oldId = -1000,
                    overflow,
                    location;
                // Bounce 6 times
                for (let j = 0; j < 6; j++) {
                    overflow = 10;
                    // Find the nearest one that's not the last one
                    do {
                        o = nearest(food, { x: ran.gauss(o.x, 30), y: ran.gauss(o.y, 30) });
                    } while (o.id === oldId && --overflow);
                    if (!overflow) continue;
                    // Configure for the nest if needed
                    let proportions = c.FOOD,
                        cens = census,
                        amount = foodAmount;
                    if (room.isIn('nest', o)) {
                        proportions = c.FOOD_NEST;
                        cens = censusNest;
                        amount = nestFoodAmount;
                    }
                    // Upgrade stuff
                    o.foodCountup += Math.ceil(Math.abs(ran.gauss(0, 10)));
                    while (o.foodCountup >= (o.foodLevel + 1) * 100) {
                        o.foodCountup -= (o.foodLevel + 1) * 100;
                        if (ran.chance(1 - cens[o.foodLevel + 1] / amount / proportions[o.foodLevel + 1])) {
                            o.define(getFoodClass(o.foodLevel + 1));
                        }
                    }
                }
            }
        };
    })();
    // Define food and food spawning
    return () => {
        // Do stuff
        makenpcs();
        makefood();
        // Regen health and update the grid
        let i = 0;
        const length = entities.length;
        //for (var instance of entities) {
        for (; i < length; i++) {
            if (entities[i].shield.max) {
                entities[i].shield.regenerate();
            }
            if (entities[i].health.amount) {
                entities[i].health.regenerate(entities[i].shield.max && entities[i].shield.max === entities[i].shield.amount);
            }
        };
    };
})();

// This is the checking loop. Runs at 1Hz.
var speedcheckloop = (() => {
    let fails = 0;
    // Return the function
    return () => {
        let activationtime = logs.activation.sum(),
            collidetime = logs.collide.sum(),
            movetime = logs.entities.sum(),
            playertime = logs.network.sum(),
            maptime = logs.minimap.sum(),
            physicstime = logs.physics.sum(),
            lifetime = logs.life.sum(),
            selfietime = logs.selfie.sum();
        let sum = logs.master.record();
        let loops = logs.loops.count(),
            active = logs.entities.count();
        global.fps = 1000 / sum;
        if (sum > 1000 / roomSpeed / global.fps) {
            //fails++;
            util.warn('~~ LOOPS: ' + loops + '. ENTITY #: ' + entities.length + '//' + Math.round(active / loops) + '. VIEW #: ' + views.length + '. BACKLOGGED :: ' + (sum * roomSpeed * 3).toFixed(3) + '%! ~~');
            util.warn('Total activation time: ' + activationtime);
            util.warn('Total collision time: ' + collidetime);
            util.warn('Total cycle time: ' + movetime);
            util.warn('Total player update time: ' + playertime);
            util.warn('Total lb+minimap processing time: ' + maptime);
            util.warn('Total entity physics calculation time: ' + physicstime);
            util.warn('Total entity life+thought cycle time: ' + lifetime);
            util.warn('Total entity selfie-taking time: ' + selfietime);
            util.warn('Total time: ' + (activationtime + collidetime + movetime + playertime + maptime + physicstime + lifetime + selfietime));
            if (fails > 60) {
                util.error("FAILURE!");
                //process.exit(1);
            }
        } else {
            fails = 0;
        }
    };
})();

/** BUILD THE SERVERS **/
// Turn the server on
var server = http.createServer(app);
var websockets = (() => {
    // Configure the websocketserver
    let config = { server: server };
    if (c.servesStatic) {
        server.listen(c.port, function httpListening() {
            util.log(new Date() + ". Joint HTTP+Websocket server turned on, listening on port " + server.address().port + ".");
        });
    } else {
        config.port = c.port;
        util.log(new Date() + 'Websocket server turned on, listening on port ' + c.port + '.');
    }
    // Build it
    return new WebSocket.Server(config);
})().on('connection', sockets.connect);

var tickLengthMs = 1000 / 20;
var previousTick = now();
var actualTicks = 0;
var gameexecution = function () {
    var current = now();

    actualTicks++;
    if (previousTick + tickLengthMs <= current) {
        //var delta = (current - previousTick) / 1000;
        var curTime = now();
        timestep = 0.01575 * (curTime - lastTime);
        if (timestep <= 0 || timestep > 7.875) {
            timestep = 0.01575;
        }

        previousTick = current;

        gameloop();

        actualTicks = 0;
        lastTime = curTime;
    }

    if (now() - previousTick < tickLengthMs - 50) {
        timer.setTimeout(gameexecution, '', '50m');
    } else {
        //timer.setTimeout(gameexecution, '', '1m');
        setImmediate(gameexecution);
    }
};

// Bring it to life
gameexecution();
//setInterval(gameloop, room.cycleSpeed);
setInterval(maintainloop, 100);
setInterval(speedcheckloop, 1000);
setInterval(poisonLoop, room.cycleSpeed * 20);

// Graceful shutdown
let shutdownWarning = false;
if (process.platform === "win32") {
    var rl = require("readline").createInterface({
        input: process.stdin,
        output: process.stdout
    });
    rl.on("SIGINT", () => {
        process.emit("SIGINT");
    });
}
process.on("SIGINT", () => {
    if (!shutdownWarning) {
        shutdownWarning = true;
        sockets.broadcast("The server is shutting down.");
        util.log('Server going down! Warning broadcasted.');
        setTimeout(() => {
            sockets.broadcast("Arena closed.");
            util.log('Final warning broadcasted.');
            setTimeout(() => {
                util.warn('Process ended.');
                process.exit();
            }, 3000);
        }, 17000);
    }
});

const Eris = require('eris');
const bot = new Eris(process.env.bot_token);

bot.on('ready', () => {
    console.log('\nBot ready!\n');
    var canLogToDiscord = true;
});

var unauth = '```patch\n- ERROR: UNATHORIZED USER```';
var mliststring = '';
var mliststring2 = '';
/*mlist.forEach(function(element) {
  if (mliststring.length < 1970) {
    mliststring += element += ', ';
  } else {
    mliststring2 += element += ', '
  }
});*/

function parse(input) {
    let out = input.split(" ");
    return out;
}

bot.on('messageCreate', msg => {
    try {
        if (msg.author.id != 452793079238361089) {
            if (msg.content.startsWith("k!select ")) {
                if (process.env.ISONGLITCH == undefined) {
                    let sendError = true;
                    let lookfor = msg.content.split("k!select ").pop();
                    function thing(element) {
                        if (typeof element.sendMessage == "function" && element.name == lookfor) {
                            sendError = false;
                            bot.createMessage(msg.channel.id, String(element.name + '\nTank: ' + element.label + '\nId: ' + element.id + '\nAlpha: ' + element.alpha + '\nColor: ' + element.blend.color + '\nMax Health: ' + element.health.max + '\nCurrent Health: ' + element.health.amount + '\nIs Invulnerable: ' + element.invuln + '\nScore: ' + element.photo.score + '\nLevel: ' + element.skill.level));
                        }
                    }
                    for (var element of entities) {
                        thing(element);
                    }
                    if (sendError) {
                        bot.createMessage(msg.channel.id, "Was unable to find an entity by that name");
                    }
                }
            }
            if (msg.content == 'k!ping') {
                bot.createMessage(msg.channel.id, 'Pong!\n' + "\nConnections amount: " + global.extPlayers + "\nRunning on glitch: " + process.env.ISONGLITCH + "\nDirectory: " + __dirname + "\nFile name: " + __filename);
            }
            if (msg.content == 'k!list') {
                //if (process.env.ISONGLITCH == undefined) {
                bot.createMessage(msg.channel.id, mliststring);
                bot.createMessage(msg.channel.id, mliststring2);
            } //}
            if (msg.content.includes('k!help')) {
                if (process.env.ISONGLITCH == undefined) {
                    bot.createMessage(msg.channel.id, '***COMMANDS*** \nPrefix: k! \n(No space after k! when running command) \n \n**ping**  -  tells u if the server is running\n**kill**  -  kills the server (Authorization required)\n**broadcast** *<message>*  -  broadcasts a message (Authorization required)\n**list**  -  Lists all tanks as their internal names\n**query** *<internalname>*  -  returns some data about a tank (use list first to get tank names that this will accept)\n**select** *<name>*  -  returns some data about in-game users\n**summon** *<type>* *<class>*  -  summons a thing\n**banish** *<id>*  -  Banishes a player (Authorization required)\n**players**  -  list in-game players\n**stat** *<id> <path to stat> <new value>*  -  modifies a stat (Authorization required)');
                }
            }
            if (msg.content == 'k!kill') {
                if (msg.author.id == 181829457852628993) {
                    console.log("\n SERVER TERMINATED BY AN AUTHORIZED USER \n");
                    bot.createMessage(msg.channel.id, 'Terminating.....');
                    process.emit("SIGINT");
                } else {
                    console.log("Unauthorized user", msg.author.username, "tried to end server");
                    bot.createMessage(msg.channel.id, unauth);
                }
            }
            if (msg.content.startsWith('k!broadcast')) {
                if (msg.author.id == 181829457852628993 || 340270483838599168) {
                    if (process.env.ISONGLITCH == undefined) {
                        sockets.broadcast(msg.content.split("k!broadcast").pop() + " - " + msg.author.username);
                        bot.createMessage(msg.channel.id, 'Message Broadcasted and rendered.');
                    }
                } else {
                    console.log("Unauthorized user", msg.author.username, "tried to broadcast a message");
                    bot.createMessage(msg.channel.id, unauth);
                }
            }
            if (msg.content.startsWith('k!query')) {
                if (process.env.ISONGLITCH == undefined) {
                    let output = '';
                    var query = msg.content.split(">query ").pop();
                    try {
                        var botreturn = eval('Class.' + query);
                        for (var key in botreturn) {
                            if (output.length > 500) {
                                console.log(output.length);bot.createMessage(msg.channel.id, output);output = '';
                            }
                            output += String(key) + ': ' + eval('Class.' + query + '.' + String(key)) + '\n';
                            var returned = typeof eval('Class.' + query + '.' + String(key));
                            if (returned == 'object') {
                                for (var key2 in eval('Class.' + query + '.' + String(key))) {
                                    if (key2 != 'remove') {
                                        try {
                                            output += "^ " + String(key2) + ': ' + eval('Class.' + query + '.' + String(key) + '[' + String(key2) + ']') + '\n';
                                            var returned = typeof eval('Class.' + query + '.' + String(key) + '[' + String(key2) + ']');
                                            var returnedobj = eval('Class.' + query + '.' + String(key) + '[' + String(key2) + ']');
                                        } catch (err) {
                                            output += "^ " + String(key2) + ': ' + eval('Class.' + query + '.' + String(key) + '.' + String(key2)) + '\n';
                                            var returned = typeof eval('Class.' + query + '.' + String(key) + '.' + String(key2));
                                            var returnedobj = eval('Class.' + query + '.' + String(key) + '.' + String(key2));
                                        }
                                        if (returned == 'object') {
                                            for (var key3 in returnedobj) {
                                                if (key3 != 'remove') {
                                                    try {
                                                        output += "^ ^ " + String(key3) + ': ' + eval('Class.' + query + '.' + String(key) + '[' + String(key2) + ']' + '[' + String(key3) + ']') + '\n';
                                                    } catch (err) {
                                                        try {
                                                            output += "^ ^ " + String(key3) + ': ' + eval('Class.' + query + '.' + String(key) + '[' + String(key2) + ']' + '.' + String(key3)) + '\n';
                                                        } catch (err) {
                                                            try {
                                                                output += "^ ^ " + String(key3) + ': ' + eval('Class.' + query + '.' + String(key) + '.' + String(key2) + '[' + String(key3) + ']') + '\n';
                                                            } catch (err) {
                                                                output += "^ ^ " + String(key3) + ': ' + eval('Class.' + query + '.' + String(key) + '.' + String(key2) + '.' + String(key3)) + '\n';
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } catch (err) {
                        bot.createMessage(msg.channel.id, String(err));
                    }
                    bot.createMessage(msg.channel.id, output);
                }
            }
            /*if (msg.content.startsWith('k!summon ')) {
              if (msg.author.id == 181829457852628993) {
                var spawnClass = msg.content.split("k!summon ").pop().substr(0, 3)
                console.log(msg.content.split("k!summon ").pop().substr(0, 3))
                var type = msg.content.split(" ").pop()
                if (spawnClass == 'bot') {
                  botSpawn = type
                  bot.createMessage(msg.channel.id, "Next bot will be a " + type);
                } else if (spawnClass == 'food') {

                } else {
                  bot.createMessage(msg.channel.id, "Was unable to complete request, unknown summon type: " + spawnClass);
                }
              } else {
                console.log("Unauthorized user", msg.author.username, "tried to broadcast")
                bot.createMessage(msg.channel.id, unauth);
              }
            }*/
            if (msg.content == 'k!players') {
                let output = '';
                let outWillFail = true;
                //entities.forEach(function(element) {
                //if (typeof element.sendMessage == "function" && element.name != '') {
                //    output += String(element.name + '  -  ' + element.id + '\n')
                //    outWillFail = false
                //}
                //})

                let i = 0;
                const length = entities.length;
                for (; i < length; i++) {
                    //for (let instance of entities) {
                    let instance = entities[i];
                    if (typeof instance.sendMessage == "function" && instance.name != '') {
                        output += String(instance.name + '  -  ' + instance.id + '\n');
                        outWillFail = false;
                    }
                }
                if (!outWillFail) {
                    bot.createMessage(msg.channel.id, output);
                } else {
                    bot.createMessage(msg.channel.id, "There are currently no players on the server");
                }
            }
            if (msg.content.startsWith('k!stat ')) {
                if (msg.author.id == 181829457852628993 || 340270483838599168 || 350336602956103683) {
                    let s_command = parse(msg.content);
                    let s_lookForId = s_command[1];
                    let s_statpath = s_command[2];
                    let s_newvalue = s_command[3];
                    entities.forEach(function (element) {
                        if (element.id == s_lookForId) {
                            try {
                                eval('element' + s_statpath + ' = ' + s_newvalue);
                            } catch (err) {
                                eval('element' + s_statpath + ' = "' + s_newvalue + '"');
                            }
                            bot.createMessage(msg.channel.id, "Value set to " + String(eval('element' + s_statpath)));
                        }
                    });
                } else {
                    bot.createMessage(msg.channel.id, unauth);
                }
            }
            if (msg.content.startsWith('k!define ')) {
                let printerror = true;
                let command = parse(msg.content);
                let inputid = command[1];
                let inputclass = command[2];
                if (msg.author.id == 181829457852628993 || 340270483838599168) {
                    if (eval(Class[inputclass]) != undefined) {
                        entities.filter(r => r.id == inputid)[0].define(Class[inputclass]);
                        printerror = false;
                        bot.createMessage(msg.channel.id, 'Defined user as Class.' + inputclass);
                    } else {
                        bot.createMessage(msg.channel.id, inputclass + ' is not a valid tank');
                    }
                    if (printerror) {
                        bot.createMessage(msg.channel.id, "Count find any users by the id: " + inputid);
                    }
                } else {
                    bot.createMessage(msg.channel.id, unauth);
                }
            }
        }
    } catch (err) {
        // log the error in chat
        bot.createMessage(msg.channel.id, String(err));
    }
});

bot.editStatus('online', {
    name: 'Type k!help for commands!',
    type: 0
});

bot.connect();exports.circleArea = function (radius) {
    return Math.pow(radius, 2) * Math.PI;
};