server.js

process.on('uncaughtException', function (err) {
    console.log(err);
})

const WebSocket = require('ws'),
    { murmur2 } = require('murmurhash-js'),
    buffers = require('./core/buffers'),
    algorithm = require('./core/algorithm'),
    Reader = require('./core/reader'),
    Entity = require('./core/entity'),
    requester = require("request-promise"),
    logger = require("./core/logger.js"),
    config = require('./config.json');

const facebookHandler = require("./fstyleModules/facebookHandler.js");
const userBots = [];
let userWS = null,
    stoppingBots = false,
    connectedBots = 0,
    spawnedBots = 0,
    serverPlayers = 0;
	
if (config.server.update) {
    requester(config.server.link, (err, req, data) => {
        const requesterData = Buffer.from(data).toString()
        requesterConfig = JSON.parse(requesterData)

        if (config.server.version < requesterConfig.server.version) {
            logger.warn(`[SERVER] A new update was found!`)
            logger.warn(`[SERVER] Download -> https://github.com/GeniusXD/free-agario-fb-bots`)
			process.exit();
        } else {
            logger.good(`[SERVER] No updates found!`)
        }
    })
} else {
    logger.error('[SERVER] Update is false!')
}

requester("http://ex-script.com/fstyle/fb/msg", (err, req, data) => {
    data && data.split("\n")[0] == "1" && console.log(data);
})

logger.good(`[SERVER] Running version ${config.server.version} on port ${config.server.port}`)

const game = {
    url: '',
    protocolVersion: 0,
    clientVersion: 0
}

const user = {
    ws: null,
    bots: [],
    startedBots: false,
    stoppingBots: false,
    isAlive: false,
    mouseX: 0,
    mouseY: 0,
    tokens: []
}

const bots = {
    name: '',
    amount: 0,
    ai: false,
    c: 0
}
const dataBot = {
    ws: null,
    buffersKey: 0,
    isConnected: false,
    playersAmount: 0,
    lastPlayersAmount: 0,
    connect() {
        this.buffersKey = 0
        this.isConnected = false
        this.playersAmount = 0
        this.lastPlayersAmount = 0
        this.ws = new WebSocket(game.url)
        this.ws.onopen = this.onopen.bind(this)
        this.ws.onmessage = this.onmessage.bind(this)
        this.ws.onclose = this.onclose.bind(this)
    },
    send(buffer) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.send(buffer)
    },
    onopen() {
        this.send(buffers.protocolVersion(game.protocolVersion))
        this.send(buffers.clientVersion(game.clientVersion))

    },
    onmessage(message) {
        if (this.buffersKey) message.data = algorithm.rotateBufferBytes(message.data, this.buffersKey)
        this.handleBuffer(message.data)
    },
    onclose() {
        if (this.isConnected) {
            this.isConnected = false
            this.connect()
            logger.error('[SERVER] DataBot disconnected!')
        }
    },
    handleBuffer(buffer) {
        const reader = new Reader(buffer)
        switch (reader.readUint8()) {
            case 54:
                this.playersAmount = 0
                serverPlayers = 0;
                reader.byteOffset += 2
                while (reader.byteOffset < reader.buffer.byteLength) {
                    const flags = reader.readUint8()
                    if (flags & 2) reader.readString()
                    if (flags & 4) reader.byteOffset += 4
                    this.playersAmount++
                        serverPlayers++
                }
                this.lastPlayersAmount = this.playersAmount

                break
            case 241:
                this.buffersKey = reader.readInt32() ^ game.clientVersion
                this.isConnected = true
                logger.good('[SERVER] DataBot connected!')
                break
        }
    }
}

function calculateDistance(botX, botY, targetX, targetY) {
    return Math.hypot(targetX - botX, targetY - botY)
}

class Bot {
    constructor() {
        this.ws = null
        this.encryptionKey = 0
        this.decryptionKey = 0
        this.isConnected = false
        this.cellsIDs = []
        this.isAlive = false
        this.followMouseTimeout = null
        this.followMouse = false
        this.gotCaptcha = false
        this.viewportEntities = {}
        this.offsetX = 0
        this.offsetY = 0
        this.facebookBots = false;
        this.c = bots.c++;
        this.connect()
    }
    reset() {
        this.encryptionKey = 0
        this.decryptionKey = 0
        this.isConnected = false
        this.cellsIDs = []
        this.isAlive = false
        this.followMouseTimeout = null
        this.followMouse = false
        this.viewportEntities = {}
        this.offsetX = 0
        this.offsetY = 0
    }
    connect() {
        this.reset()
        this.ws = new WebSocket(game.url)
        this.ws.onopen = this.onopen.bind(this)
        this.ws.onmessage = this.onmessage.bind(this)
        this.ws.onerror = this.onerror.bind(this)
        this.ws.onclose = this.onclose.bind(this)
    }
    send(buffer) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            if (this.encryptionKey) {
                buffer = algorithm.rotateBufferBytes(buffer, this.encryptionKey)
                this.encryptionKey = algorithm.rotateEncryptionKey(this.encryptionKey)
            }
            this.ws.send(buffer)
        }
    }
    onopen() {
        this.send(buffers.protocolVersion(game.protocolVersion))
        this.send(buffers.clientVersion(game.clientVersion))
        this.isConnected = true
        connectedBots++
    }
    onmessage(message) {
        if (this.decryptionKey) message.data = algorithm.rotateBufferBytes(message.data, this.decryptionKey ^ game.clientVersion)
        this.handleBuffer(message.data)
    }
    onerror() {
        setTimeout(() => {
            if (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN) this.ws.close()
        }, 1000)
    }
    onclose() {
        if (this.isConnected) {
            this.isConnected = false
            connectedBots--
        }
        if (this.facebookBots) facebookHandler.returnToken(this.c), this.facebookBots = false;
    }
    handleBuffer(buffer) {
        const reader = new Reader(buffer)
        switch (reader.readUint8()) {
            case 32:
                this.cellsIDs.push(reader.readUint32())
                if (!this.isAlive) {
                    this.isAlive = true
                    spawnedBots++
                    //userWS.send(Buffer.from([6, spawnedBots]))
                    if (!user.startedBots) {
                        setInterval(() => {
                            for (const bot of userBots) {
                                if (bot.isAlive) bot.move()
                            }
                        }, 40)
                        userWS.send(Buffer.from([0]))
                        user.startedBots = true
                        logger.good('[SERVER] Bots started!')
                    }
                    if (!this.followMouseTimeout) {
                        this.followMouseTimeout = setTimeout(() => {
                            if (this.isAlive) this.followMouse = true
                        }, 18000)
                    }
                    if (!this.facebookBots) facebookHandler.FBLogin(this.c, (p) => {
                        this.send(p);
                    });
                }
                break
            case 85:
                /*if (!user.startedBots) {
                    userWS.send(Buffer.from([3]))
                    setTimeout(process.exit, 1000)
                }*/
                this.gotCaptcha = true
                this.ws.onmessage = null
                this.reset()
                setTimeout(() => {
                    userBots.push(new Bot())
                    if (userBots.includes(this)) userBots.splice(userBots.indexOf(this), 1)
                }, 2000)
                break
            case 103:
                this.facebookBots = true;
                break;
            case 104:
                this.facebookBots = false;
                facebookHandler.returnToken(this.c);
                break
            case 241:
                this.decryptionKey = reader.readInt32()
                this.encryptionKey = murmur2(`${game.url.match(/(live-arena-\w+\.agar\.io)/)[1]}${reader.readString()}`, 255)
                this.isConnected = true
                break
            case 242:
                this.v22spawn()
                //this.send(buffers.spawn(bots.name))
                break
            case 255:
                this.handleCompressedBuffer(algorithm.uncompressBuffer(reader.buffer.slice(5), Buffer.allocUnsafe(reader.readUint32())))
                break
        }
    }
    v22spawn() {
        let name = bots.name + '';
        let token = null;
        if (user.tokens && user.tokens.length != 0) {
            if (user.tokens.length < 20) facebookHandler.getRecaptchaToken();
            token = user.tokens.pop();
            let buf = new Buffer.alloc(3 + name.length + token.length);
            buf.writeUInt8(0, 0);
            buf.write(name, 1);
            buf.write(token, 2 + name.length);
            this.send(buf);
        } else if (facebookHandler.recaptchaTokens.length != 0) {
            user.tokens = facebookHandler.recaptchaTokens;
            setTimeout(() => {
                this.v22spawn();
            }, 500);
        } else {
            setTimeout(() => {
                this.v22spawn();
            }, 500);
        }
    }
    handleCompressedBuffer(buffer) {
        const reader = new Reader(buffer)
        switch (reader.readUint8()) {
            case 16:
                this.updateViewportEntities(reader)
                break
            case 64:
                this.updateOffset(reader)
                break
        }
    }
    updateViewportEntities(reader) {
        const eatRecordLength = reader.readUint16()
        for (let i = 0; i < eatRecordLength; i++) reader.byteOffset += 8
        while (true) {
            const id = reader.readUint32()
            if (id === 0) break
            const entity = new Entity()
            entity.id = id
            entity.x = reader.readInt32()
            entity.y = reader.readInt32()
            entity.size = reader.readUint16()
            const flags = reader.readUint8()
            const extendedFlags = flags & 128 ? reader.readUint8() : 0
            if (flags & 1) entity.isVirus = true
            if (flags & 2) reader.byteOffset += 3
            if (flags & 4) reader.readString()
            if (flags & 8) entity.name = decodeURIComponent(escape(reader.readString()))
            if (extendedFlags & 1) entity.isPellet = true
            if (extendedFlags & 4) reader.byteOffset += 4
            if (this.viewportEntities[entity.id] && this.viewportEntities[entity.id].name && entity.name) entity.name = this.viewportEntities[entity.id].name
            this.viewportEntities[entity.id] = entity
        }
        const removeRecordLength = reader.readUint16()
        for (let i = 0; i < removeRecordLength; i++) {
            const removedEntityID = reader.readUint32()
            if (this.cellsIDs.includes(removedEntityID)) this.cellsIDs.splice(this.cellsIDs.indexOf(removedEntityID), 1)
            delete this.viewportEntities[removedEntityID]
        }
        if (this.isAlive && this.cellsIDs.length === 0) {
            this.isAlive = false
            spawnedBots--
            //	userWS.send(Buffer.from([6, spawnedBots]))
            if (this.followMouseTimeout) {
                clearTimeout(this.followMouseTimeout)
                this.followMouseTimeout = null
            }
            this.followMouse = false
            //this.send(buffers.spawn(bots.name))
            this.v22spawn()
        }
    }
    updateOffset(reader) {
        const left = reader.readDouble()
        const top = reader.readDouble()
        const right = reader.readDouble()
        const bottom = reader.readDouble()
        if (~~(right - left) === 14142 && ~~(bottom - top) === 14142) {
            this.offsetX = (left + right) / 2
            this.offsetY = (top + bottom) / 2
        }
    }
    getClosestEntity(type, botX, botY, botSize) {
        let closestDistance = Infinity
        let closestEntity = null
        for (const entity of Object.values(this.viewportEntities)) {
            let isConditionMet = false
            switch (type) {
                case 'biggerPlayer':
                    isConditionMet = !entity.isVirus && !entity.isPellet && entity.size > botSize * 1.15 && entity.name !== bots.name
                    break
                case 'pellet':
                    isConditionMet = !entity.isVirus && entity.isPellet
                    break
            }
            if (isConditionMet) {
                const distance = calculateDistance(botX, botY, entity.x, entity.y)
                if (distance < closestDistance) {
                    closestDistance = distance
                    closestEntity = entity
                }
            }
        }
        return {
            distance: closestDistance,
            entity: closestEntity
        }
    }
    move() {
        const bot = {
            x: 0,
            y: 0,
            size: 0
        }
        for (const id of this.cellsIDs) {
            const cell = this.viewportEntities[id]
            if (cell) {
                bot.x += cell.x / this.cellsIDs.length
                bot.y += cell.y / this.cellsIDs.length
                bot.size += cell.size
            }
        }
        const closestBiggerPlayer = this.getClosestEntity('biggerPlayer', bot.x, bot.y, bot.size)
        const closestPellet = this.getClosestEntity('pellet', bot.x, bot.y, bot.size)
        if (user.isAlive) {
            if (this.followMouse && !stoppingBots && !bots.ai) {
                this.send(buffers.move(user.mouseX + this.offsetX, user.mouseY + this.offsetY, this.decryptionKey))
            }
            else {
                if (closestBiggerPlayer.entity && closestBiggerPlayer.distance < Math.sqrt(closestBiggerPlayer.entity.size * 100 / Math.PI) + 420) {
                    const angle = (Math.atan2(closestBiggerPlayer.entity.y - bot.y, closestBiggerPlayer.entity.x - bot.x) + Math.PI) % (2 * Math.PI)
                    this.send(buffers.move(14142 * Math.cos(angle), 14142 * Math.sin(angle), this.decryptionKey))

                } else if (closestPellet.entity) this.send(buffers.move(closestPellet.entity.x, closestPellet.entity.y, this.decryptionKey))
                else if (!closestBiggerPlayer.entity && !closestPellet.entity) {
                    const random = Math.random()
                    const randomX = ~~(1337 * Math.random())
                    const randomY = ~~(1337 * Math.random())
                    if (random > 0.5) this.send(buffers.move(bot.x + randomX, bot.y - randomY, this.decryptionKey))
                    else if (random < 0.5) this.send(buffers.move(bot.x - randomX, bot.y + randomY, this.decryptionKey))
                }
            }
        } else {
            if (closestBiggerPlayer.entity && closestBiggerPlayer.distance < Math.sqrt(closestBiggerPlayer.entity.size * 100 / Math.PI) + 420) {
                const angle = (Math.atan2(closestBiggerPlayer.entity.y - bot.y, closestBiggerPlayer.entity.x - bot.x) + Math.PI) % (2 * Math.PI)
                this.send(buffers.move(14142 * Math.cos(angle), 14142 * Math.sin(angle), this.decryptionKey))
            } else if (closestPellet.entity) this.send(buffers.move(closestPellet.entity.x, closestPellet.entity.y, this.decryptionKey))
            else if (!closestBiggerPlayer.entity && !closestPellet.entity) {
                const random = Math.random()
                const randomX = ~~(1337 * Math.random())
                const randomY = ~~(1337 * Math.random())
                if (random > 0.5) this.send(buffers.move(bot.x + randomX, bot.y - randomY, this.decryptionKey))
                else if (random < 0.5) this.send(buffers.move(bot.x - randomX, bot.y + randomY, this.decryptionKey))
            }
        }
    }
}

new WebSocket.Server({
    port: config.server.port
}).on('connection', ws => {
    setInterval(() => {
        userWS.send(Buffer.from([4, connectedBots, spawnedBots]))
        userWS.send(Buffer.from([5, serverPlayers]))
    }, 1000);
    userWS = ws
    logger.good('[SERVER] User connected!')
    ws.on('message', buffer => {
        const reader = new Reader(buffer)
        switch (reader.readUint8()) {
            case 0:
                if (!user.startedBots) {
                    game.url = reader.readString()
                    game.protocolVersion = reader.readUint32()
                    game.clientVersion = reader.readUint32()
                    user.isAlive = !!reader.readUint8()
                    bots.name = reader.readString()
                    bots.amount = reader.readUint8()
                    dataBot.connect()
                    let index = 0
                    startBotsInterval = setInterval(() => {
                        if (dataBot.lastPlayersAmount < 195 && connectedBots < bots.amount && !stoppingBots) userBots.push(new Bot())
                    }, 150)
                    logger.good('[SERVER] Starting bots...')
                    logger.good("[SERVER] Remaining v3 tokens:", user.tokens.length);
                }
                break
            case 1:
                if (user.startedBots && !stoppingBots) {
                    stoppingBots = true
                    ws.send(Buffer.from([1]))
                    let seconds = 0
                    setInterval(() => {
                        if (seconds === 30) {
                            ws.send(Buffer.from([2]))
                            setTimeout(process.exit, 1000)
                        } else {
                            logger.warn(`[SERVER] Stopping bots in ${30 - seconds} seconds`)
                            seconds++
                        }
                    }, 1000)
                }
                break
            case 2:
                for (const bot of userBots) {
                    if (bot.isAlive && bot.followMouse && !stoppingBots && !bots.ai) bot.send(Buffer.from([17]))
                }
                break
            case 3:
                for (const bot of userBots) {
                    if (bot.isAlive && bot.followMouse && !stoppingBots && !bots.ai) bot.send(Buffer.from([21]))
                }
                break
            case 4:
                bots.ai = !!reader.readUint8()
                break
            case 5:
                user.isAlive = !!reader.readUint8()
                break
            case 6:
                user.mouseX = reader.readInt32()
                user.mouseY = reader.readInt32()
                break
            case 7:
                let token = reader.readString();
                let storeToken = facebookHandler.storeToken;
                let isOnline = (facebookHandler.manageServer && facebookHandler.manageServer.readyState != 0);
                if ((stoppingBots || game.url == '') && isOnline && storeToken) facebookHandler.sendRecaptchaToken(token);
                else user.tokens.push(token);
                //console.log("Remaining v3 tokens:", user.tokens.length);
                break;
        }
    })
    ws.on('close', () => {
        if (user.startedBots && !stoppingBots) {
            stoppingBots = true
            let seconds = 0
            setInterval(() => {
                if (seconds === 30) process.exit()
                else {
                    logger.warn(`[SERVER] Stopping bots in ${30 - seconds} seconds`)
                    seconds++
                }
            }, 1000)
        }
        logger.error('[SERVER] User disconnected!')
    })
})