yolkbot 0.1.0-alpha.9 → 0.1.1-alpha.10

package/src/bot.js

@@ -1,4 +1,4 @@
-import { loginAnonymously, loginWithCredentials } from '#api';
+import { createAccount, loginAnonymously, loginWithCredentials, loginWithRefreshToken, queryServices } from '#api';
 
 import CommIn from './comm/CommIn.js';
 import CommOut from './comm/CommOut.js';
@@ -9,6 +9,7 @@ import Matchmaker from './matchmaker.js';
 import yolkws from './socket.js';
 
 import {
+    ChiknWinnerDailyLimit,
     CollectTypes,
     CoopStates,
     findItemById,
@@ -17,8 +18,10 @@ import {
     GameOptionFlags,
     GunList,
     IsBrowser,
+    ItemTypes,
     Movements,
     PlayTypes,
+    ProxiesEnabled,
     ShellStreaks
 } from '#constants';
 
@@ -32,30 +35,32 @@ import { Maps } from './constants/maps.js';
 const CoopStagesById = Object.fromEntries(Object.entries(CoopStates).map(([key, value]) => [value, key]));
 const GameModesById = Object.fromEntries(Object.entries(GameModes).map(([key, value]) => [value, key]));
 
+const intents = {
+    CHALLENGES: 1,
+    STATS: 2,
+    PATHFINDING: 3,
+    BUFFERS: 4,
+    PING: 5,
+    COSMETIC_DATA: 6,
+    PLAYER_HEALTH: 7,
+    PACKET_HOOK: 8
+}
+
 export class Bot {
-    // params.name - the bot name
-    // params.proxy - a socks(4|5) proxy
-    // params.doUpdate - whether to auto update
-    // params.updateInterval - the auto update interval
-    // params.doPing - whether to auto ping (for bot.<ping>)
-    // params.pingInterval - the ping interval
-    // params.doPathing - whether to run pathfinding logic
-    // params.instance - a custom shell URL to run requests through
+    static Intents = intents;
+    Intents = intents;
+
     constructor(params = {}) {
-        if (params.proxy && IsBrowser)
+        if (params.proxy && !ProxiesEnabled)
             throw new Error('proxies do not work and hence are not supported in the browser');
 
+        this.intents = params.intents || [];
+
+        this.instance = params.instance || 'shellshock.io';
         this.proxy = params.proxy || '';
-        this.name = params.name || Math.random().toString(36).substring(8);
 
-        this.autoPing = params.doPing || true;
         this.autoUpdate = params.doUpdate || true;
-        this.disablePathing = !params.doPathing || true;
-
-        this.pingInterval = params.pingInterval || 1000;
-        this.updateInterval = params.updateInterval || 5;
-
-        this.instance = params.instance || 'shellshock.io';
+        this.updateInterval = params.updateInterval || 16.5;
 
         this._hooks = {};
         this._globalHooks = [];
@@ -63,10 +68,10 @@ export class Bot {
 
         // private information NOT FOR OTHER PLAYERS!!
         this.state = {
-            loggedIn: false,
-            gameFound: false,
+            // kept for specifying socket open sequence
+            name: '',
 
-            // once we implement more packets these may be moved to "players"
+            // tracking for dispatch checks
             reloading: false,
             swappingGun: false,
             usingMelee: false,
@@ -81,6 +86,7 @@ export class Bot {
         this.game = {
             raw: {}, // matchmaker response
             code: '',
+            socket: null,
 
             // data given on sign in
             gameModeId: 0, // assume ffa
@@ -98,8 +104,10 @@ export class Bot {
                 },
                 availability: 'both',
                 numPlayers: '18',
+
                 raw: {},
-                nodes: {}
+                nodes: {},
+                zones: []
             },
             playerLimit: 0,
             isGameOwner: false,
@@ -135,7 +143,8 @@ export class Bot {
 
             // data from kotc
             stage: CoopStates.capturing,
-            activeZone: 0,
+            zoneNumber: 0,
+            activeZone: [],
             capturing: 0,
             captureProgress: 0,
             numCapturing: 0,
@@ -145,10 +154,23 @@ export class Bot {
 
         this.account = {
             // used for auth
+            id: 0,
             firebaseId: '',
             sessionId: '',
             session: '',
 
+            // raw login params
+            email: '',
+            password: '',
+
+            // chikn winner related info
+            cw: {
+                atLimit: false,
+                limit: 0,
+                secondsUntilPlay: 0, // short cooldown, in seconds
+                canPlayAgain: Date.now()
+            },
+
             // used for skin changing
             loadout: {
                 hatId: null,
@@ -184,21 +206,17 @@ export class Bot {
         this._dispatches = [];
         this._packetQueue = [];
 
-        this.gameSocket = null;
+        this.matchmaker = null;
 
         this.ping = 0;
         this.lastPingTime = -1;
 
         this.lastDeathTime = -1;
         this.lastChatTime = -1;
-
         this.lastUpdateTime = -1;
-        this.nUpdates = 0;
 
         this.controlKeys = 0;
 
-        this.initTime = Date.now();
-
         this.pathing = {
             nodeList: null,
             followingPath: false,
@@ -206,90 +224,111 @@ export class Bot {
             activeNode: null,
             activeNodeIdx: 0
         }
+
+        if (this.intents.includes(this.Intents.PLAYER_HEALTH)) this.healthIntervalId = setInterval(() => {
+            if (!this.players) return;
+
+            for (const player of Object.values(this.players)) {
+                if (player.playing && player.hp > 0) {
+                    const regenSpeed = 0.1 * (this.game.isPrivate ? this.game.options.healthRegen : 1);
+
+                    if (player.streakRewards.includes(ShellStreaks.OverHeal)) {
+                        player.hp = Math.max(100, player.hp - regenSpeed);
+                    } else {
+                        player.hp = Math.min(100, player.hp + regenSpeed);
+                    }
+                }
+            }
+        }, 33);
     }
 
-    async login(email, pass) {
-        // const time = Date.now();
+    dispatch(disp) {
+        this._dispatches.push(disp);
+    }
+
+    async createAccount(email, pass) {
+        this.account.email = email;
+        this.account.password = pass;
 
-        this.email = email;
-        this.pass = pass;
+        const loginData = await createAccount(email, pass, this.proxy, this.instance);
+        return await this.#processLoginData(loginData);
+    }
+
+    async login(email, pass) {
+        this.account.email = email;
+        this.account.password = pass;
 
         const loginData = await loginWithCredentials(email, pass, this.proxy, this.instance);
+        return await this.#processLoginData(loginData);
+    }
+
+    async loginWithRefreshToken(refreshToken) {
+        const loginData = await loginWithRefreshToken(refreshToken, this.proxy, this.instance);
+        return await this.#processLoginData(loginData);
+    }
 
+    async loginAnonymously() {
+        delete this.account.email;
+        delete this.account.password;
+
+        const loginData = await loginAnonymously(this.proxy, this.instance);
+        return await this.#processLoginData(loginData);
+    }
+
+    async #processLoginData(loginData) {
         if (typeof loginData == 'string') {
-            this.#emit('authFail', loginData);
+            this.emit('authFail', loginData);
             return false;
         }
 
         if (loginData.banRemaining) {
-            this.#emit('banned', loginData.banRemaining);
+            this.emit('banned', loginData.banRemaining);
             return false;
         }
 
-        this.state.loggedIn = true;
-
         this.account.rawLoginData = loginData;
 
         this.account.accountAge = loginData.accountAge;
         this.account.eggBalance = loginData.currentBalance;
         this.account.emailVerified = loginData.emailVerified;
         this.account.firebaseId = loginData.firebaseId;
+        this.account.id = loginData.id;
         this.account.loadout = loginData.loadout;
         this.account.ownedItemIds = loginData.ownedItemIds;
+        this.account.session = loginData.session;
         this.account.sessionId = loginData.sessionId;
         this.account.vip = loginData.upgradeProductId && !loginData.upgradeIsExpired;
 
-        // console.log('Logged in successfully. Time:', Date.now() - time, 'ms');
+        if (this.intents.includes(this.Intents.STATS)) this.account.stats = {
+            lifetime: loginData.statsLifetime,
+            monthly: loginData.statsCurrent
+        };
 
-        return this.account;
-    }
+        if (this.intents.includes(this.Intents.CHALLENGES)) {
+            this.account.challenges = [];
 
-    dispatch(disp) {
-        this._dispatches.push(disp);
-    }
+            const { Challenges } = await import('./constants/challenges.js');
 
-    drain() {
-        for (let i = 0; i < this._dispatches.length; i++) {
-            const disp = this._dispatches[i];
-            if (disp.check(this)) {
-                disp.execute(this);
-                this._dispatches.splice(i, 1);
-                return; // only 1 dispatch per update
-            } else {
-                // console.log("Dispatch failed", this.state.joinedGame, this.lastChatTime)
-            }
-        }
-    }
+            for (const challenge of loginData.challenges) {
+                const challengeData = Challenges.find(c => c.id == challenge.challengeId);
+                if (!challengeData) continue;
 
-    async #anonLogin() {
-        const loginData = await loginAnonymously(this.proxy, this.instance);
+                delete challenge.playerId;
 
-        if (typeof loginData == 'string') {
-            this.#emit('authFail', loginData);
-            return false;
+                this.account.challenges.push({
+                    ...challengeData,
+                    ...challenge
+                });
+            }
         }
 
-        this.state.loggedIn = true;
-
-        this.account.rawLoginData = loginData;
-
-        this.account.accountAge = loginData.accountAge;
-        this.account.eggBalance = loginData.currentBalance;
-        this.account.emailVerified = loginData.emailVerified;
-        this.account.firebaseId = loginData.firebaseId;
-        this.account.loadout = loginData.loadout;
-        this.account.ownedItemIds = loginData.ownedItemIds;
-        this.account.session = loginData.session;
-        this.account.sessionId = loginData.sessionId;
-        this.account.vip = false;
-
         return this.account;
     }
 
     async initMatchmaker() {
-        if (!this.state.loggedIn) {
+        if (this.account.id == 0) {
             // console.log('Not logged in, attempting to create anonymous user...');
-            const anonLogin = await this.#anonLogin();
+            const anonLogin = await this.loginAnonymously();
             if (!anonLogin) return false;
         }
 
@@ -301,7 +340,7 @@ export class Bot {
                 instance: this.instance
             });
 
-            this.matchmaker.on('authFail', (data) => this.#emit('authFail', data));
+            this.matchmaker.on('authFail', (data) => this.emit('authFail', data));
 
             await this.matchmaker.getRegions();
         }
@@ -312,34 +351,33 @@ export class Bot {
     async #joinGameWithCode(code) {
         if (!await this.initMatchmaker()) return false;
 
-        const listener = (mes) => {
-            if (mes.command == 'gameFound') {
-                this.game.raw = mes;
-                this.game.code = code;
-                delete this.game.raw.command; // pissed me off
+        return await new Promise((resolve) => {
+            const listener = (mes) => {
+                if (mes.command == 'gameFound') {
+                    this.matchmaker.off('msg', listener);
 
-                this.gameFound = true;
-            }
+                    this.game.raw = mes;
+                    this.game.code = code;
 
-            if (mes.error && mes.error == 'gameNotFound')
-                throw new Error(`Game ${code} not found (likely expired).`)
-        };
-
-        this.matchmaker.on('msg', listener);
+                    resolve();
+                }
 
-        this.matchmaker.send({
-            command: 'joinGame',
-            id: code,
-            observe: false,
-            sessionId: this.account.sessionId
-        })
+                if (mes.error && mes.error == 'gameNotFound')
+                    throw new Error(`Game ${code} not found (likely expired).`)
+            };
 
-        while (!this.gameFound) await new Promise(r => setTimeout(r, 10));
+            this.matchmaker.on('msg', listener);
 
-        this.matchmaker.off('msg', listener);
+            this.matchmaker.send({
+                command: 'joinGame',
+                id: code,
+                observe: false,
+                sessionId: this.account.sessionId
+            })
+        });
     }
 
-    async #onGameMesssage(msg) { // to minify with vscode
+    async #onGameMesssage(msg) {
         CommIn.init(msg.data);
 
         let out;
@@ -350,7 +388,7 @@ export class Bot {
                 out = CommOut.getBuffer();
                 out.packInt8(CommCode.joinGame);
 
-                out.packString(this.name); // name
+                out.packString(this.state.name); // name
                 out.packString(this.game.raw.uuid); // game id
 
                 out.packInt8(0); // hidebadge
@@ -360,10 +398,10 @@ export class Bot {
                 out.packString(this.account.firebaseId); // firebase id
                 out.packString(this.account.sessionId); // session id
 
-                out.send(this.gameSocket);
+                out.send(this.game.socket);
                 break;
 
-            case CommCode.gameJoined:
+            case CommCode.gameJoined: {
                 this.me.id = CommIn.unPackInt8U();
                 // console.log("My id is:", this.me.id);
                 this.me.team = CommIn.unPackInt8U();
@@ -373,9 +411,10 @@ export class Bot {
                 // console.log("Gametype:", this.game.gameMode, this.game.gameModeId);
                 this.game.mapIdx = CommIn.unPackInt8U();
                 this.game.map = Maps[this.game.mapIdx];
-                if (!this.disablePathing) {
+                if (this.intents.includes(this.Intents.PATHFINDING)) {
                     this.game.map.raw = await this.#fetchMap(this.game.map.filename, this.game.map.hash);
                     this.pathing.nodeList = new NodeList(this.game.map.raw);
+                    if (this.game.gameModeId === GameModes.kotc) this.#initKotcZones();
                 }
                 // console.log("Map:", this.game.map);
                 this.game.playerLimit = CommIn.unPackInt8U();
@@ -389,34 +428,34 @@ export class Bot {
                 this.state.joinedGame = true;
                 this.lastDeathTime = Date.now();
 
+                const out = CommOut.getBuffer();
+                out.packInt8(CommCode.clientReady);
+                out.send(this.game.socket);
+
+                this.game.socket.onmessage = (msg) => this._packetQueue.push(msg.data);
+
+                if (this.autoUpdate)
+                    this.updateIntervalId = setInterval(() => this.update(), this.updateInterval);
+
+                if (this.intents.includes(this.Intents.PING)) {
+                    const out = CommOut.getBuffer();
+                    out.packInt8(CommCode.ping);
+                    out.send(this.game.socket);
+                    this.lastPingTime = Date.now();
+                }
                 break;
+            }
 
             case CommCode.eventModifier:
                 // console.log("Echoed eventModifier"); // why the fuck do you need to do this
                 out = CommOut.getBuffer();
                 out.packInt8(CommCode.eventModifier);
-                out.send(this.gameSocket);
+                out.send(this.game.socket);
                 break;
 
-            case CommCode.requestGameOptions: {
-                out = CommOut.getBuffer();
-                out.packInt8(CommCode.gameOptions);
-                out.packInt8(this.game.options.gravity * 4);
-                out.packInt8(this.game.options.damage * 4);
-                out.packInt8(this.game.options.healthRegen * 4);
-
-                const flags =
-                    (this.game.options.locked ? 1 : 0) |
-                    (this.game.options.noTeamChange ? 2 : 0) |
-                    (this.game.options.noTeamShuffle ? 4 : 0);
-
-                out.packInt8(flags);
-
-                this.game.options.weaponsDisabled.forEach((v) => {
-                    out.packInt8(v ? 1 : 0);
-                });
+            case CommCode.requestGameOptions:
+                this.#processGameRequestOptionsPacket();
                 break;
-            }
 
             default:
                 try {
@@ -449,52 +488,50 @@ export class Bot {
 
         if (mapIdx == -1) throw new Error('invalid map, see the Maps constant for a list')
 
-        const listener = (msg) => {
-            if (msg.command == 'gameFound') {
-                this.game.raw = msg;
-                this.game.code = this.game.raw.id;
-                delete this.game.raw.command;
-
-                this.gameFound = true;
-            }
-        };
+        await new Promise((resolve) => {
+            const listener = (msg) => {
+                if (msg.command == 'gameFound') {
+                    this.matchmaker.off('msg', listener);
 
-        this.matchmaker.on('msg', listener);
+                    this.game.raw = msg;
+                    this.game.code = this.game.raw.id;
 
-        this.matchmaker.send({
-            command: 'findGame',
-            region: opts.region,
-            playType: PlayTypes.createPrivate,
-            gameType: GameModes[opts.mode],
-            sessionId: this.account.sessionId,
-            noobLobby: false,
-            map: mapIdx
-        });
+                    resolve();
+                }
+            };
 
-        while (!this.gameFound) await new Promise(r => setTimeout(r, 10));
+            this.matchmaker.on('msg', listener);
 
-        this.matchmaker.off('msg', listener);
+            this.matchmaker.send({
+                command: 'findGame',
+                region: opts.region,
+                playType: PlayTypes.createPrivate,
+                gameType: GameModes[opts.mode],
+                sessionId: this.account.sessionId,
+                noobLobby: false,
+                map: mapIdx
+            });
+        });
 
         return this.game.raw;
     }
 
-    async join(data) {
+    async join(name, data) {
+        this.state.name = name || 'yolkbot';
+
         if (typeof data == 'string') {
             if (data.includes('#')) data = data.split('#')[1]; // stupid shell kids put in full links
             // this is a string code that we can pass and get the needed info from
             await this.#joinGameWithCode(data);
         } else if (typeof data == 'object') {
-            if (!this.state.loggedIn) {
+            if (this.account.id == 0) {
                 // console.log('passed an object but you still need to be logged in!!')
-                await this.#anonLogin();
+                await this.loginAnonymously();
             }
 
             // this is a game object that we can pass and get the needed info from
             this.game.raw = data;
             this.game.code = this.game.raw.id;
-            delete this.game.raw.command;
-
-            this.gameFound = true;
         }
 
         if (!this.game.raw.id || !this.game.raw.subdomain)
@@ -502,115 +539,115 @@ export class Bot {
 
         // console.log(`Joining ${this.game.raw.id} using proxy ${this.proxy || 'none'}`);
 
-        this.gameSocket = new yolkws(`wss://${this.game.raw.subdomain}.${this.instance}/game/${this.game.raw.id}`, this.proxy);
+        const attempt = async () => {
+            try {
+                this.game.socket = new yolkws(`wss://${this.game.raw.subdomain}.${this.instance}/game/${this.game.raw.id}`, this.proxy);
+            } catch {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                await attempt();
+            }
+        }
+
+        await attempt();
 
-        this.gameSocket.binaryType = 'arraybuffer';
+        this.game.socket.binaryType = 'arraybuffer';
 
-        this.gameSocket.onopen = () => {
+        this.game.socket.onopen = () => {
             // console.log('Successfully connected to game server.');
         }
 
-        this.gameSocket.onmessage = this.#onGameMesssage.bind(this);
+        this.game.socket.onmessage = this.#onGameMesssage.bind(this);
 
-        this.gameSocket.onclose = (e) => {
+        this.game.socket.onclose = (e) => {
             // console.log('Game socket closed:', e.code, Object.entries(CloseCode).filter(([, v]) => v == e.code));
-            this.#emit('close', e.code);
-        }
-
-        while (!this.state.joinedGame) await new Promise(r => setTimeout(r, 5));
-
-        const out = CommOut.getBuffer();
-        out.packInt8(CommCode.clientReady);
-        out.send(this.gameSocket);
-
-        this.gameSocket.onmessage = (msg) => this._packetQueue.push(msg.data);
-
-        // console.log(`Successfully joined ${this.game.code}. Startup to join time: ${Date.now() - this.initTime} ms`);
-
-        if (this.autoUpdate)
-            setInterval(() => this.update(), this.updateInterval);
-
-        if (this.autoPing) {
-            const out = CommOut.getBuffer();
-            out.packInt8(CommCode.ping);
-            out.send(this.gameSocket);
-            this.lastPingTime = Date.now();
+            this.emit('close', e.code);
         }
     }
 
-    update() {
-        if (!this.state.joinedGame) { throw new Error('Not playing, can\'t update. '); }
-
-        this.nUpdates++;
+    #processPathfinding() {
+        const myPositionStr = Object.entries(this.me.position).map(entry => Math.floor(entry[1])).join(',');
 
-        if (this._packetQueue.length === 0 && this._dispatches.length === 0) return;
+        if (myPositionStr == this.pathing.activePath[this.pathing.activePath.length - 1].positionStr()) {
+            // console.log('Completed path to', this.pathing.activePath[this.pathing.activePath.length - 1].position);
+            this.pathing.followingPath = false;
+            this.pathing.activePath = null;
+            this.pathing.activeNode = null;
+            this.pathing.activeNodeIdx = 0;
 
-        let packet;
-        while ((packet = this._packetQueue.shift()) !== undefined) { this.#handlePacket(packet); }
-
-        this.drain();
-
-        if (this.pathing.followingPath && !this.disablePathing) {
-            const myPositionStr = Object.entries(this.me.position).map(entry => Math.floor(entry[1])).join(',');
-
-            if (myPositionStr == this.pathing.activePath[this.pathing.activePath.length - 1].positionStr()) {
-                // console.log('Completed path to', this.pathing.activePath[this.pathing.activePath.length - 1].position);
-                this.pathing.followingPath = false;
-                this.pathing.activePath = null;
-                this.pathing.activeNode = null;
-                this.pathing.activeNodeIdx = 0;
-
-                this.dispatch(new MovementDispatch(0));
+            this.dispatch(new MovementDispatch(0));
+        } else {
+            let positionTarget;
+            if (this.pathing.activeNodeIdx < this.pathing.activePath.length - 1) {
+                positionTarget = this.pathing.activePath[this.pathing.activeNodeIdx + 1].flatCenter();
+                this.dispatch(new LookAtPosDispatch(positionTarget));
             } else {
-                let positionTarget;
-                if (this.pathing.activeNodeIdx < this.pathing.activePath.length - 1) {
-                    positionTarget = this.pathing.activePath[this.pathing.activeNodeIdx + 1].flatCenter();
-                    this.dispatch(new LookAtPosDispatch(positionTarget));
-                } else {
-                    positionTarget = this.pathing.activePath[this.pathing.activeNodeIdx].flatCenter();
-                    this.dispatch(new LookAtPosDispatch(positionTarget));
-                }
+                positionTarget = this.pathing.activePath[this.pathing.activeNodeIdx].flatCenter();
+                this.dispatch(new LookAtPosDispatch(positionTarget));
+            }
 
-                for (const node of this.pathing.activePath) {
-                    if (node.flatRadialDistance(this.me.position) < 0.1 && node.position.y == Math.floor(this.me.position.y)) {
-                        if (this.pathing.activePath.indexOf(node) >= this.pathing.activeNodeIdx) {
-                            this.pathing.activeNodeIdx = this.pathing.activePath.indexOf(node) + 1;
-                            this.pathing.activeNode = this.pathing.activePath[this.pathing.activeNodeIdx];
-                            break;
-                        } else {
-                            // console.log('Close to node that\'s before, idx:', 
-                            //    this.pathing.activePath.indexOf(node), 'current:', this.pathing.activeNodeIdx);
-                        }
+            for (const node of this.pathing.activePath) {
+                if (node.flatRadialDistance(this.me.position) < 0.1 && node.position.y == Math.floor(this.me.position.y)) {
+                    if (this.pathing.activePath.indexOf(node) >= this.pathing.activeNodeIdx) {
+                        this.pathing.activeNodeIdx = this.pathing.activePath.indexOf(node) + 1;
+                        this.pathing.activeNode = this.pathing.activePath[this.pathing.activeNodeIdx];
+                        break;
                     } else {
-                        // console.log('Node at', node.position, 'is', node.flatRadialDistance(this.me.position), 'away.')
+                        // console.log('Close to node that\'s before, idx:', 
+                        //    this.pathing.activePath.indexOf(node), 'current:', this.pathing.activeNodeIdx);
                     }
-                    // console.log('activeNode is ', this.pathing.activeNode.flatRadialDistance(this.me.position), 'away');
+                } else {
+                    // console.log('Node at', node.position, 'is', node.flatRadialDistance(this.me.position), 'away.')
                 }
+                // console.log('activeNode is ', this.pathing.activeNode.flatRadialDistance(this.me.position), 'away');
+            }
 
-                if (!(this.controlKeys & Movements.FORWARD)) {
-                    this.dispatch(new MovementDispatch(Movements.FORWARD));
-                }
+            if (!(this.controlKeys & Movements.FORWARD)) {
+                this.dispatch(new MovementDispatch(Movements.FORWARD));
             }
+        }
 
-            /*let onPath = false;
-            for (const node of this.pathing.activePath) {
-                if (node.positionStr() == myPositionStr) {
-                    onPath = true;
-                    break;
+        /*let onPath = false;
+        for (const node of this.pathing.activePath) {
+            if (node.positionStr() == myPositionStr) {
+                onPath = true;
+                break;
+            }
+        }
+        if (!onPath) {
+            console.log('Got off-path somehow');
+            this.dispatch(new PathfindDispatch(this.pathing.activePath[this.pathing.activePath.length - 1]));
+            this.pathing.followingPath = false;
+            this.pathing.activePath = null;
+            this.pathing.activeNode = null;
+            this.pathing.activeNodeIdx = 0;
+        }*/
+    }
+
+    update() {
+        if (!this.state.joinedGame) throw new Error('Not playing, can\'t update. ');
+
+        // process pathfinding
+        if (this.pathing.followingPath && this.intents.includes(this.Intents.PATHFINDING)) this.#processPathfinding();
+
+        // process incoming packets
+        while (this._packetQueue.length > 0) this.#handlePacket(this._packetQueue.shift());
+
+        // process dispatches
+        if (this._dispatches.length > 0) {
+            for (let i = 0; i < this._dispatches.length; i++) {
+                const disp = this._dispatches[i];
+                if (disp.check(this)) {
+                    disp.execute(this);
+                    this._dispatches.splice(i, 1);
+                    break; // only 1 dispatch per update
                 }
             }
-            if (!onPath) {
-                console.log('Got off-path somehow');
-                this.dispatch(new PathfindDispatch(this.pathing.activePath[this.pathing.activePath.length - 1]));
-                this.pathing.followingPath = false;
-                this.pathing.activePath = null;
-                this.pathing.activeNode = null;
-                this.pathing.activeNodeIdx = 0;
-            }*/
         }
 
-        if (Date.now() - this.lastUpdateTime >= 50) {
-            this.#emit('tick');
+        // process syncMe
+        const now = Date.now();
+        if (now - this.lastUpdateTime >= 50) {
+            this.emit('tick');
 
             // Send out update packet
             const out = CommOut.getBuffer();
@@ -624,14 +661,16 @@ export class Bot {
                 out.packRad(this.me.view.pitch); // pitch
                 out.packInt8(100); // fixes commcode issues, does nothing
             }
-            out.send(this.gameSocket);
+            out.send(this.game.socket);
 
-            this.lastUpdateTime = Date.now();
+            this.lastUpdateTime = now;
             this.state.shotsFired = 0;
         }
 
-        let cb;
-        while ((cb = this._liveCallbacks.shift()) !== undefined) cb();
+        while (this._liveCallbacks.length > 0) {
+            const cb = this._liveCallbacks.shift();
+            cb();
+        }
     }
 
     on(event, cb) {
@@ -646,7 +685,7 @@ export class Bot {
     // these are auth-related codes (liveCallbacks doesn't run during auth)
     #mustBeInstant = ['authFail', 'banned'];
 
-    #emit(event, ...args) {
+    emit(event, ...args) {
         if (this._hooks[event]) {
             for (const cb of this._hooks[event]) {
                 if (this.#mustBeInstant.includes(event)) cb(...args);
@@ -664,30 +703,90 @@ export class Bot {
         if (!IsBrowser) {
             const { existsSync, mkdirSync, readFileSync, writeFileSync } = await import('node:fs');
             const { join } = await import('node:path');
+            const { homedir } = await import('node:os');
 
-            if (existsSync(join(import.meta.dirname, '..', 'data', 'cache', 'maps', `${name}-${hash}.json`))) {
-                return JSON.parse(readFileSync(join(import.meta.dirname, '..', 'data', 'cache', 'maps', `${name}-${hash}.json`), 'utf-8'));
-            }
+            const yolkbotCache = join(homedir(), '.yolkbot');
+            const mapCache = join(yolkbotCache, 'maps');
+
+            if (!existsSync(yolkbotCache)) mkdirSync(yolkbotCache);
+            if (!existsSync(mapCache)) mkdirSync(mapCache);
+
+            const mapFile = join(mapCache, `${name}-${hash}.json`);
 
-            console.warn(`Map "${name}" not found in cache, fetching...`);
+            if (existsSync(mapFile))
+                return JSON.parse(readFileSync(mapFile, 'utf-8'));
+
+            console.log('map not in cache, IMPORT!!', name, hash);
 
             const data = await (await fetch(`https://${this.instance}/maps/${name}.json?${hash}`)).json();
 
-            const dir = join(import.meta.dirname, '..', 'data', 'cache', 'maps');
-            if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+            writeFileSync(mapFile, JSON.stringify(data, null, 4), { flag: 'w+' });
 
-            writeFileSync(
-                join(dir, `${name}-${hash}.json`),
-                JSON.stringify(data, null, 4),
-                { flag: 'w+' }
-            );
             return data;
         } else {
-            const data = await (await fetch(`https://${this.instance}/maps/${name}.json?${hash}`)).json();
+            const data = await (await fetch(`https://esm.sh/gh/yolkorg/maps/maps/${name}.json`)).json();
             return data;
         }
     }
 
+    #initKotcZones() {
+        const meshData = this.game.map.raw.data['DYNAMIC.capture-zone.none'];
+        if (!meshData) return delete this.game.map.zones;
+
+        let numCaptureZones = 0;
+        const mapData = {};
+        const zones = [];
+
+        for (const cell of meshData) {
+            if (!mapData[cell.x]) mapData[cell.x] = {};
+            if (!mapData[cell.x][cell.y]) mapData[cell.x][cell.y] = {};
+            mapData[cell.x][cell.y][cell.z] = { zone: null };
+        }
+
+        const offsets = [
+            { x: -1, z: 0 },
+            { x: 1, z: 0 },
+            { x: 0, z: -1 },
+            { x: 0, z: 1 }
+        ];
+
+        function getMapCellAt(x, y, z) {
+            return mapData[x] && mapData[x][y] && mapData[x][y][z] ? mapData[x][y][z] : null;
+        }
+
+        for (const cellA of meshData) {
+            if (!mapData[cellA.x][cellA.y][cellA.z].zone) {
+                cellA.zone = ++numCaptureZones;
+                mapData[cellA.x][cellA.y][cellA.z].zone = cellA.zone;
+
+                const currentZone = [cellA];
+                let hits;
+
+                do {
+                    hits = 0;
+                    for (const cellB of meshData) {
+                        if (!mapData[cellB.x][cellB.y][cellB.z].zone) {
+                            for (const o of offsets) {
+                                const cell = getMapCellAt(cellB.x + o.x, cellB.y, cellB.z + o.z);
+                                if (cell && cell.zone == cellA.zone) {
+                                    hits++;
+                                    cellB.zone = cellA.zone;
+                                    mapData[cellB.x][cellB.y][cellB.z].zone = cellA.zone;
+                                    currentZone.push(cellB);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                } while (hits > 0);
+
+                zones.push(currentZone);
+            }
+        }
+
+        this.game.map.zones = zones;
+    }
+
     #processChatPacket() {
         const id = CommIn.unPackInt8U();
         const msgFlags = CommIn.unPackInt8U();
@@ -695,7 +794,7 @@ export class Bot {
         const player = this.players[Object.keys(this.players).find(p => this.players[p].id == id)];
         // console.log(`Player ${player.name}: ${text} (flags: ${msgFlags})`);
         // console.log(`Their position: ${player.position.x}, ${player.position.y}, ${player.position.z}`);
-        this.#emit('chat', player, text, msgFlags);
+        this.emit('chat', player, text, msgFlags);
     }
 
     #processAddPlayerPacket() {
@@ -704,6 +803,7 @@ export class Bot {
         const name = CommIn.unPackString();
         const safename = CommIn.unPackString(); // ??? (a)
         const charClass = CommIn.unPackInt8U();
+        const findCosmetics = this.intents.includes(this.Intents.COSMETIC_DATA);
         const playerData = {
             id_: id_,
             uniqueId_: uniqueId,
@@ -712,14 +812,14 @@ export class Bot {
             charClass_: charClass,
             team_: CommIn.unPackInt8U(),
             primaryWeaponItem_: findItemById(CommIn.unPackInt16U()),
-            secondaryWeaponItem_: findItemById(CommIn.unPackInt16U()), // b
+            secondaryWeaponItem_: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
             shellColor_: CommIn.unPackInt8U(),
-            hatItem_: findItemById(CommIn.unPackInt16U()),
-            stampItem_: findItemById(CommIn.unPackInt16U()),
+            hatItem_: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
+            stampItem_: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
             unknownInt8: CommIn.unPackInt8(), // c
             otherUnknownInt8: CommIn.unPackInt8(),
-            grenadeItem_: findItemById(CommIn.unPackInt16U()),
-            meleeItem_: findItemById(CommIn.unPackInt16U()),
+            grenadeItem_: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
+            meleeItem_: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
             x_: CommIn.unPackFloat(),
             y_: CommIn.unPackFloat(),
             z_: CommIn.unPackFloat(),
@@ -752,36 +852,14 @@ export class Bot {
         playerData.gameData_.private = CommIn.unPackInt8U();
         playerData.gameData_.gameType = CommIn.unPackInt8U();
 
-        if (!this.players[playerData.id_]) {
+        if (!this.players[playerData.id_])
             this.players[playerData.id_] = new GamePlayer(playerData.id_, playerData.team_, playerData);
 
-            const player = this.players[playerData.id_];
-
-            if (player.playing) {
-                player.healthInterval = setInterval(() => {
-                    if (player.hp < 1) return;
-
-                    const regenSpeed = 0.1 * (this.game.isPrivate ? this.game.options.healthRegen : 1);
-
-                    if (player.streakRewards.includes(ShellStreaks.OverHeal)) {
-                        player.hp = Math.max(100, player.hp - regenSpeed);
-                    } else {
-                        player.hp = Math.min(100, player.hp + regenSpeed);
-                    }
-                }, 33);
-            }
-        }
-
         if (this.me.id == playerData.id_) {
             this.me = this.players[playerData.id_];
         }
 
-        this.#emit('playerJoin', this.players[playerData.id_]);
-
-        const unp = CommIn.unPackInt8U();
-        if (unp == CommCode.addPlayer) { // there is another player stacked
-            this.#processAddPlayerPacket();
-        }
+        this.emit('playerJoin', this.players[playerData.id_]);
     }
 
     #processRespawnPacket() {
@@ -808,29 +886,13 @@ export class Bot {
             player.grenades = grenades;
             player.position = { x: x, y: y, z: z };
             // console.log(`Player ${player.name} respawned at ${x}, ${y}, ${z}`);
-            this.#emit('playerRespawn', player);
-
-            if (player.healthInterval) {
-                clearInterval(player.healthInterval);
-            }
-
-            player.healthInterval = setInterval(() => {
-                if (player.hp < 1) return;
-
-                const regenSpeed = 0.1 * (this.game.isPrivate ? this.game.options[GameOptionFlags.healthRegen] : 1);
-
-                if (player.streakRewards.includes(ShellStreaks.OverHeal)) {
-                    player.hp = Math.max(100, player.hp - regenSpeed);
-                } else {
-                    player.hp = Math.min(100, player.hp + regenSpeed);
-                }
-            }, 33);
+            this.emit('playerRespawn', player);
         } else {
             // console.log(`Player ${id} not found. (me: ${this.me.id}) (respawn)`);
         }
     }
 
-    #processExternalSyncPacket() {
+    #processSyncThemPacket() {
         const id = CommIn.unPackInt8U();
         const x = CommIn.unPackFloat();
         const y = CommIn.unPackFloat();
@@ -838,37 +900,50 @@ export class Bot {
         const climbing = CommIn.unPackInt8U();
 
         const player = this.players[id];
-        if (!player || !player.buffer) return;
-
-        if (player.id == this.me.id) {
+        if (!player || player.id == this.me.id) {
             for (let i2 = 0; i2 < 3 /* FramesBetweenSyncs */; i2++) {
                 CommIn.unPackInt8U();
                 CommIn.unPackRadU();
                 CommIn.unPackRad();
+                CommIn.unPackInt8U();
             }
+            return;
         }
 
-        let yaw, pitch;
-        for (let i2 = 0; i2 < 3; i2++) {
-            player.buffer[i2].controlKeys = CommIn.unPackInt8U();
-            yaw = CommIn.unPackRadU();
-            if (!isNaN(yaw)) { player.buffer[i2].yaw_ = yaw }
-            pitch = CommIn.unPackRad();
-            if (!isNaN(pitch)) { player.buffer[i2].pitch_ = pitch }
-        }
-
-        player.position.x = x;
+        if (player.position.x !== x) player.position.x = x;
+        if (player.position.z !== z) player.position.z = z;
 
-        if (!player.jumping || Math.abs(player.position.y - y) > 0.5) {
+        if (!player.jumping || Math.abs(player.position.y - y) > 0.5 && player.position.y !== y)
             player.position.y = y;
-        }
 
-        player.position.z = z;
-        player.buffer[0].x = x;
-        player.buffer[0].y = y;
-        player.buffer[0].z = z;
-        player.climbing = climbing;
-        // console.log(`Player ${player.name} is now at ${x}, ${y}, ${z} (climbing = ${climbing})`);
+        if (player.climbing !== climbing) player.climbing = climbing;
+
+        if (this.intents.includes(this.Intents.BUFFERS)) {
+            if (!player.buffer) return;
+
+            for (let i2 = 0; i2 < 3; i2++) {
+                player.buffer[i2].controlKeys = CommIn.unPackInt8U();
+
+                const yaw = CommIn.unPackRadU();
+                if (!isNaN(yaw)) player.buffer[i2].yaw_ = yaw
+
+                const pitch = CommIn.unPackRad();
+                if (!isNaN(pitch)) player.buffer[i2].pitch_ = pitch
+
+                CommIn.unPackInt8U();
+            }
+
+            player.buffer[0].x = x;
+            player.buffer[0].y = y;
+            player.buffer[0].z = z;
+        } else {
+            for (let i2 = 0; i2 < 3; i2++) {
+                CommIn.unPackInt8U();
+                CommIn.unPackRadU();
+                CommIn.unPackRad();
+                CommIn.unPackInt8U();
+            }
+        }
     }
 
     #processPausePacket() {
@@ -876,7 +951,7 @@ export class Bot {
         const player = this.players[id];
         if (player) {
             player.playing = false;
-            this.#emit('playerPause', player);
+            this.emit('playerPause', player);
         }
     }
 
@@ -887,23 +962,21 @@ export class Bot {
         const player = this.players[id];
         if (player) {
             player.activeGun = newWeaponId;
-            this.#emit('playerSwapWeapon', player, newWeaponId);
+            this.emit('playerSwapWeapon', player, newWeaponId);
         }
     }
 
     #processDeathPacket() {
         const killedId = CommIn.unPackInt8U();
         const byId = CommIn.unPackInt8U();
-        // const rs = CommIn.unPackInt8U();
+
+        CommIn.unPackInt8U();
+        CommIn.unPackInt8U();
+        CommIn.unPackInt8U();
 
         const killed = this.players[killedId];
         const killer = this.players[byId];
 
-        /*
-        const killerLastDmg = CommIn.unPackInt8U();
-        const killedLastDmg = CommIn.unPackInt8U();
-        */
-
         if (killed) {
             killed.playing = false;
             killed.kills = 0;
@@ -914,18 +987,21 @@ export class Bot {
         if (killer) { killer.kills++; }
         // console.log(`Player ${killer.name} is on a streak of ${killer.kills} kills.`);
 
-        this.#emit('playerDeath', killed, killer); // killed, killer
+        this.emit('playerDeath', killed, killer); // killed, killer
     }
 
     #processFirePacket() {
         const id = CommIn.unPackInt8U();
 
+        for (let i = 0; i < 6; i++)
+            CommIn.unPackFloat();
+
         const player = this.players[id];
         const playerWeapon = player.weapons[player.activeGun];
 
         if (playerWeapon && playerWeapon.ammo) {
             playerWeapon.ammo.rounds--;
-            this.#emit('playerFire', player, playerWeapon);
+            this.emit('playerFire', player, playerWeapon);
         }
     }
 
@@ -938,7 +1014,7 @@ export class Bot {
 
         this.game.collectables[type].push({ id, x, y, z });
 
-        this.#emit('spawnItem', type, id, { x, y, z });
+        this.emit('spawnItem', type, id, { x, y, z });
     }
 
     #processCollectPacket() {
@@ -955,13 +1031,15 @@ export class Bot {
             const playerWeapon = player.weapons[applyToWeaponIdx];
             if (playerWeapon && playerWeapon.ammo) {
                 playerWeapon.ammo.store = Math.min(playerWeapon.ammo.storeMax, playerWeapon.ammo.store + playerWeapon.ammo.pickup);
-                this.#emit('collectAmmo', player, playerWeapon);
+                this.emit('collectAmmo', player, playerWeapon);
             }
         }
 
         if (type == CollectTypes.GRENADE) {
-            player.grenades >= 3 ? player.grenades = 3 : player.grenades++;
-            this.#emit('collectGrenade', player);
+            player.grenades++;
+            if (player.grenades > 3) player.grenades = 3
+
+            this.emit('collectGrenade', player);
         }
     }
 
@@ -975,16 +1053,19 @@ export class Bot {
         const oldHP = player.hp;
         player.hp = hp;
 
-        this.#emit('playerDamaged', player, oldHP, player.hp);
+        this.emit('playerDamaged', player, oldHP, player.hp);
     }
 
     #processHitMePacket() {
         const hp = CommIn.unPackInt8U();
-        const oldHp = this.me.hp;
 
+        CommIn.unPackFloat();
+        CommIn.unPackFloat();
+
+        const oldHp = this.me.hp;
         this.me.hp = hp;
 
-        this.#emit('selfDamaged', oldHp, this.me.hp);
+        this.emit('selfDamaged', oldHp, this.me.hp);
     }
 
     #processSyncMePacket() {
@@ -1001,6 +1082,10 @@ export class Bot {
         const newY = CommIn.unPackFloat();
         const newZ = CommIn.unPackFloat();
 
+        CommIn.unPackInt8U();
+        CommIn.unPackInt8U();
+        CommIn.unPackInt8U();
+
         const oldX = player.position.x;
         const oldY = player.position.y;
         const oldZ = player.position.z;
@@ -1010,14 +1095,14 @@ export class Bot {
         player.position.z = newZ;
 
         if (oldX != newX || oldY != newY || oldZ != newZ) {
-            this.#emit('selfMoved', player, { x: oldX, y: oldY, z: oldZ }, { x: newX, y: newY, z: newZ });
+            this.emit('selfMoved', player, { x: oldX, y: oldY, z: oldZ }, { x: newX, y: newY, z: newZ });
         }
     }
 
     #processEventModifierPacket() {
         const out = CommOut.getBuffer();
         out.packInt8(CommCode.eventModifier);
-        out.send(this.gameSocket);
+        out.send(this.game.socket);
     }
 
     #processRemovePlayerPacket() {
@@ -1026,7 +1111,7 @@ export class Bot {
 
         delete this.players[id.toString()];
 
-        this.#emit('playerLeave', removedPlayer);
+        this.emit('playerLeave', removedPlayer);
     }
 
     #processGameStatePacket() {
@@ -1049,10 +1134,10 @@ export class Bot {
                 controlledByTeam: controlledByTeam
             };
 
-            this.#emit('gameStateChange', this.game);
+            this.emit('gameStateChange', this.game);
         } else if (this.game.gameModeId == GameModes.kotc) {
             this.game.stage = CommIn.unPackInt8U(); // constants.CoopStates
-            this.game.activeZone = CommIn.unPackInt8U(); // a number to represent which 'active zone' kotc is using
+            this.game.zoneNumber = CommIn.unPackInt8U(); // a number to represent which 'active zone' kotc is using
             this.game.capturing = CommIn.unPackInt8U(); // the team capturing, named "teams" in shell src
             this.game.captureProgress = CommIn.unPackInt16U(); // progress of the coop capture
             this.game.numCapturing = CommIn.unPackInt8U(); // number of players capturing - number/1000
@@ -1062,8 +1147,12 @@ export class Bot {
             // not in shell, for utility purposes =D
             this.game.stageName = CoopStagesById[this.game.stage]; // name of the stage ('start' / 'capturing' / 'etc')
             this.game.capturePercent = this.game.captureProgress / 1000; // progress of the capture as a percentage
+            this.game.activeZone = this.game.map.zones ? this.game.map.zones[this.game.zoneNumber - 1] : null;
 
-            this.#emit('gameStateChange', this.game);
+            this.emit('gameStateChange', this.game);
+        } else if (this.game.gameModeId == GameModes.team) {
+            this.game.teamScore[1] = CommIn.unPackInt16U();
+            this.game.teamScore[2] = CommIn.unPackInt16U();
         }
 
         if (this.game.gameModeId !== GameModes.spatula) {
@@ -1072,13 +1161,16 @@ export class Bot {
 
         if (this.game.gameModeId !== GameModes.kotc) {
             delete this.game.stage;
-            delete this.game.activeZone;
+            delete this.game.zoneNumber;
             delete this.game.capturing;
             delete this.game.captureProgress;
-            delete this.game.numCapturing
+            delete this.game.numCapturing;
+            delete this.game.stageName;
+            delete this.game.numCapturing;
+            delete this.game.activeZone;
         }
 
-        if (this.game.gameModeId !== GameModes.spatula && this.game.gameModeId !== GameModes.kotc) {
+        if (this.game.gameModeId == GameModes.ffa) {
             delete this.game.teamScore;
         }
     }
@@ -1129,7 +1221,7 @@ export class Bot {
                 break;
         }
 
-        this.#emit('playerBeginStreak', player, ksType);
+        this.emit('playerBeginStreak', player, ksType);
     }
 
     #processEndStreakPacket() {
@@ -1148,21 +1240,24 @@ export class Bot {
             player.streakRewards = player.streakRewards.filter((r) => r != ksType);
         }
 
-        this.#emit('playerEndStreak', ksType, player);
+        this.emit('playerEndStreak', ksType, player);
     }
 
     #processHitShieldPacket() {
         const hb = CommIn.unPackInt8U();
         const hp = CommIn.unPackInt8U();
 
+        CommIn.unPackFloat();
+        CommIn.unPackFloat();
+
         this.me.hpShield = hb;
         this.me.hp = hp;
 
         if (this.me.hpShield <= 0) {
             this.me.streakRewards = this.me.streakRewards.filter((r) => r != ShellStreaks.HardBoiled);
-            this.#emit('selfShieldLost');
+            this.emit('selfShieldLost');
         } else {
-            this.#emit('selfShieldHit', this.me.hpShield);
+            this.emit('selfShieldHit', this.me.hpShield);
         }
     }
 
@@ -1191,7 +1286,7 @@ export class Bot {
         this.game.options.weaponsDisabled = Array.from({ length: 7 }, () => CommIn.unPackInt8U() === 1);
         this.game.options.mustUseSecondary = this.game.options.weaponsDisabled.every((v) => v);
 
-        this.#emit('gameOptionsChange', oldOptions, this.game.options);
+        this.emit('gameOptionsChange', oldOptions, this.game.options);
         return false;
     }
 
@@ -1200,7 +1295,7 @@ export class Bot {
 
         if (action == GameActions.pause) {
             // console.log('settings changed, gameOwner changed game settings, force paused');
-            this.#emit('gameForcePause');
+            this.emit('gameForcePause');
             setTimeout(() => this.me.playing = false, 3000);
         }
 
@@ -1208,35 +1303,43 @@ export class Bot {
             // console.log('owner reset game');
 
             this.me.kills = 0;
-            this.game.teamScore = [0, 0, 0];
 
-            this.game.spatula.controlledBy = 0;
-            this.game.spatula.controlledByTeam = 0;
-            this.game.spatula.coords = { x: 0, y: 0, z: 0 };
+            if (this.game.gameModeId !== GameModes.ffa) this.game.teamScore = [0, 0, 0];
+
+            if (this.game.gameModeId === GameModes.spatula) {
+                this.game.spatula.controlledBy = 0;
+                this.game.spatula.controlledByTeam = 0;
+                this.game.spatula.coords = { x: 0, y: 0, z: 0 };
+            }
 
-            this.game.stage = CoopStates.capturing;
-            this.game.activeZone = 0;
-            this.game.capturing = 0;
-            this.game.captureProgress = 0;
-            this.game.numCapturing = 0;
-            this.game.stageName = CoopStagesById[CoopStates.capturing];
-            this.game.capturePercent = 0.0;
+            if (this.game.gameModeId === GameModes.kotc) {
+                this.game.stage = CoopStates.capturing;
+                this.game.zoneNumber = 0;
+                this.game.activeZone = null;
+                this.game.capturing = 0;
+                this.game.captureProgress = 0;
+                this.game.numCapturing = 0;
+                this.game.stageName = CoopStagesById[CoopStates.capturing];
+                this.game.capturePercent = 0.0;
+            }
 
-            this.#emit('gameReset');
+            this.emit('gameReset');
         }
     }
 
     #processPingPacket() {
+        if (!this.intents.includes(this.Intents.PING)) return;
+
         const oldPing = this.ping;
 
         this.ping = Date.now() - this.lastPingTime;
 
-        this.#emit('pingUpdate', oldPing, this.ping);
+        this.emit('pingUpdate', oldPing, this.ping);
 
         setTimeout(() => {
             const out = CommOut.getBuffer();
             out.packInt8(CommCode.ping);
-            out.send(this.gameSocket);
+            out.send(this.game.socket);
             this.lastPingTime = Date.now();
         }, this.pingInterval);
     }
@@ -1253,7 +1356,7 @@ export class Bot {
         player.team = toTeam;
         player.kills = 0;
 
-        this.#emit('playerSwitchTeam', player, oldTeam, toTeam);
+        this.emit('playerSwitchTeam', player, oldTeam, toTeam);
     }
 
     #processChangeCharacterPacket() {
@@ -1268,12 +1371,18 @@ export class Bot {
         const grenadeIdx = CommIn.unPackInt16U();
         const meleeIdx = CommIn.unPackInt16U();
 
+        CommIn.unPackInt8();
+        CommIn.unPackInt8();
+
+        const findCosmetics = this.intents.includes(this.Intents.COSMETIC_DATA);
+
         const primaryWeaponItem = findItemById(primaryWeaponIdx);
-        const secondaryWeaponItem = findItemById(secondaryWeaponIdx);
-        const hatItem = findItemById(hatIdx);
-        const stampItem = findItemById(stampIdx);
-        const grenadeItem = findItemById(grenadeIdx);
-        const meleeItem = findItemById(meleeIdx);
+
+        const secondaryWeaponItem = findCosmetics ? findItemById(secondaryWeaponIdx) : secondaryWeaponIdx;
+        const hatItem = findCosmetics ? findItemById(hatIdx) : hatIdx;
+        const stampItem = findCosmetics ? findItemById(stampIdx) : stampIdx;
+        const grenadeItem = findCosmetics ? findItemById(grenadeIdx) : grenadeIdx;
+        const meleeItem = findCosmetics ? findItemById(meleeIdx) : meleeIdx;
 
         const player = this.players[id];
         if (player) {
@@ -1291,8 +1400,8 @@ export class Bot {
             player.selectedGun = weaponIndex;
             player.weapons[0] = new GunList[weaponIndex]();
 
-            if (oldWeaponIdx !== player.selectedGun) this.#emit('playerChangeGun', player, oldWeaponIdx, player.selectedGun);
-            if (oldCharacter !== player.character) this.#emit('playerChangeCharacter', player, oldCharacter, player.character);
+            if (oldWeaponIdx !== player.selectedGun) this.emit('playerChangeGun', player, oldWeaponIdx, player.selectedGun);
+            if (oldCharacter !== player.character) this.emit('playerChangeCharacter', player, oldCharacter, player.character);
         }
     }
 
@@ -1301,27 +1410,23 @@ export class Bot {
         const oldBalance = this.account.eggBalance;
 
         this.account.eggBalance = newBalance;
-        this.#emit('balanceUpdate', newBalance - oldBalance, newBalance);
+        this.emit('balanceUpdate', newBalance - oldBalance, newBalance);
     }
 
     #processRespawnDeniedPacket() {
         this.me.playing = false;
-        this.#emit('selfRespawnFail');
+        this.emit('selfRespawnFail');
     }
 
     #processMeleePacket() {
         const id = CommIn.unPackInt8U();
         const player = this.players[id];
 
-        if (player) this.#emit('playerMelee', player);
+        if (player) this.emit('playerMelee', player);
     }
 
-    // we do this since reload doesn't get emitted to ourselves
-    processReloadPacket(customPlayer, iUnderstandThisIsForInternalUseOnlyAndIShouldNotBeCallingThis) {
-        if (!iUnderstandThisIsForInternalUseOnlyAndIShouldNotBeCallingThis)
-            throw new Error('processReloadPacket is exposed for internal use only. do not call it.');
-
-        const id = customPlayer || CommIn.unPackInt8U();
+    #processReloadPacket() {
+        const id = CommIn.unPackInt8U();
         const player = this.players[id];
 
         if (!player) return;
@@ -1338,142 +1443,444 @@ export class Bot {
             playerActiveWeapon.ammo.store -= newRounds;
         }
 
-        this.#emit('playerReload', player, playerActiveWeapon);
+        this.emit('playerReload', player, playerActiveWeapon);
+    }
+
+    #processGameRequestOptionsPacket() {
+        const out = CommOut.getBuffer();
+        out.packInt8(CommCode.gameOptions);
+        out.packInt8(this.game.options.gravity * 4);
+        out.packInt8(this.game.options.damage * 4);
+        out.packInt8(this.game.options.healthRegen * 4);
+
+        const flags =
+            (this.game.options.locked ? 1 : 0) |
+            (this.game.options.noTeamChange ? 2 : 0) |
+            (this.game.options.noTeamShuffle ? 4 : 0);
+
+        out.packInt8(flags);
+
+        this.game.options.weaponsDisabled.forEach((v) => {
+            out.packInt8(v ? 1 : 0);
+        });
+    }
+
+    #processExplodePacket() {
+        const itemType = CommIn.unPackInt8U();
+        let item = CommIn.unPackInt16U();
+        const x = CommIn.unPackFloat();
+        const y = CommIn.unPackFloat();
+        const z = CommIn.unPackFloat();
+        const damage = CommIn.unPackInt8U();
+        const radius = CommIn.unPackFloat();
+
+        if (this.intents.includes(this.Intents.COSMETIC_DATA))
+            item = findItemById(item);
+
+        if (itemType == ItemTypes.Grenade) this.emit('grenadeExploded', item, { x, y, z }, damage, radius);
+        else this.emit('rocketHit', { x, y, z }, damage, radius);
+    }
+
+    #processThrowGrenadePacket() {
+        const id = CommIn.unPackInt8U();
+        const x = CommIn.unPackFloat();
+        const y = CommIn.unPackFloat();
+        const z = CommIn.unPackFloat();
+        const dx = CommIn.unPackFloat();
+        const dy = CommIn.unPackFloat();
+        const dz = CommIn.unPackFloat();
+
+        const player = this.players[id];
+
+        if (player) {
+            player.grenades--;
+            this.emit('playerThrowGrenade', player, { x, y, z }, { x: dx, y: dy, z: dz });
+        }
+    }
+
+    #processChallengeCompletePacket() {
+        const id = CommIn.unPackInt8U();
+        const challengeId = CommIn.unPackInt8U();
+
+        const player = this.players[id];
+        if (!player) return;
+
+        if (!this.intents.includes(this.Intents.CHALLENGES))
+            return this.emit('challengeComplete', player, challengeId);
+
+        const challenge = this.account.challenges.find(c => c.id == challengeId);
+        this.emit('challengeComplete', player, challenge);
+
+        if (player.id == this.me.id) this.refreshChallenges();
     }
 
     #handlePacket(packet) {
         CommIn.init(packet);
-        this.#emit('packet', packet);
-        const cmd = CommIn.unPackInt8U();
-        switch (cmd) {
-            case CommCode.chat:
-                this.#processChatPacket(packet);
-                break;
 
-            case CommCode.addPlayer:
-                this.#processAddPlayerPacket(packet);
-                break;
+        if (this.intents.includes(this.Intents.PACKET_HOOK))
+            this.emit('packet', packet);
 
-            case CommCode.respawn:
-                this.#processRespawnPacket(packet);
-                break;
+        let lastCommand = 0;
+        let abort = false;
 
-            case CommCode.swapWeapon:
-                this.#processSwapWeaponPacket(packet);
-                break;
+        while (CommIn.isMoreDataAvailable() && !abort) {
+            const cmd = CommIn.unPackInt8U();
 
-            case CommCode.syncThem:
-                this.#processExternalSyncPacket(packet);
-                break;
+            switch (cmd) {
+                case CommCode.syncThem:
+                    this.#processSyncThemPacket();
+                    break;
 
-            case CommCode.pause:
-                this.#processPausePacket(packet);
-                break;
+                case CommCode.fire:
+                    this.#processFirePacket();
+                    break;
 
-            case CommCode.die:
-                this.#processDeathPacket(packet);
-                break;
+                case CommCode.hitThem:
+                    this.#processHitThemPacket();
+                    break;
 
-            case CommCode.fire:
-                this.#processFirePacket(packet);
-                break;
+                case CommCode.syncMe:
+                    this.#processSyncMePacket();
+                    break;
 
-            case CommCode.collectItem:
-                this.#processCollectPacket(packet);
-                break;
+                case CommCode.hitMe:
+                    this.#processHitMePacket();
+                    break;
 
-            case CommCode.hitThem:
-                this.#processHitThemPacket(packet);
-                break;
+                case CommCode.swapWeapon:
+                    this.#processSwapWeaponPacket();
+                    break;
 
-            case CommCode.hitMe:
-                this.#processHitMePacket(packet);
-                break;
+                case CommCode.collectItem:
+                    this.#processCollectPacket();
+                    break;
 
-            case CommCode.syncMe:
-                this.#processSyncMePacket(packet);
-                break;
+                case CommCode.respawn:
+                    this.#processRespawnPacket();
+                    break;
 
-            case CommCode.eventModifier:
-                this.#processEventModifierPacket(packet);
-                break;
+                case CommCode.die:
+                    this.#processDeathPacket();
+                    break;
 
-            case CommCode.removePlayer:
-                this.#processRemovePlayerPacket(packet);
-                break;
+                case CommCode.pause:
+                    this.#processPausePacket();
+                    break;
 
-            case CommCode.metaGameState:
-                this.#processGameStatePacket(packet);
-                break;
+                case CommCode.chat:
+                    this.#processChatPacket();
+                    break;
 
-            case CommCode.beginShellStreak:
-                this.#processBeginStreakPacket(packet);
-                break;
+                case CommCode.addPlayer:
+                    this.#processAddPlayerPacket();
+                    break;
 
-            case CommCode.endShellStreak:
-                this.#processEndStreakPacket(packet);
-                break;
+                case CommCode.removePlayer:
+                    this.#processRemovePlayerPacket();
+                    break;
 
-            case CommCode.hitMeHardBoiled:
-                this.#processHitShieldPacket(packet);
-                break;
+                case CommCode.eventModifier:
+                    this.#processEventModifierPacket();
+                    break;
 
-            case CommCode.gameOptions:
-                this.#processGameOptionsPacket(packet);
-                break;
+                case CommCode.metaGameState:
+                    this.#processGameStatePacket();
+                    break;
 
-            case CommCode.gameAction:
-                this.#processGameActionPacket(packet);
-                break;
+                case CommCode.beginShellStreak:
+                    this.#processBeginStreakPacket();
+                    break;
 
-            case CommCode.ping:
-                this.#processPingPacket(packet);
-                break;
+                case CommCode.endShellStreak:
+                    this.#processEndStreakPacket();
+                    break;
 
-            case CommCode.switchTeam:
-                this.#processSwitchTeamPacket(packet);
-                break;
+                case CommCode.hitMeHardBoiled:
+                    this.#processHitShieldPacket();
+                    break;
 
-            case CommCode.changeCharacter:
-                this.#processChangeCharacterPacket(packet);
-                break;
+                case CommCode.gameOptions:
+                    this.#processGameOptionsPacket();
+                    break;
 
-            case CommCode.updateBalance:
-                this.#processUpdateBalancePacket(packet);
-                break;
+                case CommCode.ping:
+                    this.#processPingPacket();
+                    break;
 
-            case CommCode.respawnDenied:
-                this.#processRespawnDeniedPacket(packet);
-                break;
+                case CommCode.switchTeam:
+                    this.#processSwitchTeamPacket();
+                    break;
 
-            case CommCode.reload:
-                this.processReloadPacket(null, true);
-                break;
+                case CommCode.changeCharacter:
+                    this.#processChangeCharacterPacket();
+                    break;
 
-            case CommCode.spawnItem:
-                this.#processSpawnItemPacket();
-                break;
+                case CommCode.reload:
+                    this.#processReloadPacket();
+                    break;
 
-            case CommCode.melee:
-                this.#processMeleePacket();
-                break;
+                case CommCode.explode:
+                    this.#processExplodePacket();
+                    break;
+
+                case CommCode.throwGrenade:
+                    this.#processThrowGrenadePacket();
+                    break;
+
+                case CommCode.spawnItem:
+                    this.#processSpawnItemPacket();
+                    break;
+
+                case CommCode.melee:
+                    this.#processMeleePacket();
+                    break;
+
+                case CommCode.updateBalance:
+                    this.#processUpdateBalancePacket();
+                    break;
+
+                case CommCode.challengeCompleted:
+                    this.#processChallengeCompletePacket();
+                    break;
+
+                case CommCode.gameAction:
+                    this.#processGameActionPacket();
+                    break;
+
+                case CommCode.requestGameOptions:
+                    this.#processGameRequestOptionsPacket();
+                    break;
+
+                case CommCode.respawnDenied:
+                    this.#processRespawnDeniedPacket();
+                    break;
 
-            case CommCode.clientReady:
-            case CommCode.expireUpgrade:
-            case CommCode.musicInfo:
-            case CommCode.challengeCompleted:
                 // we do not plan to implement these
                 // for more info, see comm/codes.js
-                break;
+                case CommCode.clientReady:
+                case CommCode.expireUpgrade:
+                    break;
 
-            case CommCode.explode:
-            case CommCode.throwGrenade:
-                // do nothing
-                break;
+                case CommCode.musicInfo:
+                    CommIn.unPackLongString();
+                    break;
 
-            default:
-                console.error(`handlePacket: I got but did not handle a: ${Object.entries(CommCode).filter(([, v]) => v == cmd)[0][0]}`);
-                break;
+                default:
+                    console.error(`handlePacket: I got but did not handle a: ${Object.keys(CommCode).find(k => CommCode[k] === cmd)}`);
+                    if (lastCommand) console.error(`handlePacket: It may be a result of the ${lastCommand} command.`);
+                    abort = true
+                    break;
+            }
+
+            lastCommand = Object.keys(CommCode).find(k => CommCode[k] === cmd);
+        }
+    }
+
+    async checkChiknWinner() {
+        const response = await queryServices({
+            cmd: 'chicknWinnerReady',
+            id: this.account.id,
+            sessionId: this.account.sessionId
+        });
+
+        this.account.cw.limit = response.limit;
+        this.account.cw.atLimit = response.limit > 3;
+
+        // if there is a "span", that means that it's under the daily limit and you can play again soon
+        // if there is a "period", that means that the account is done for the day and must wait a long time
+        this.account.cw.secondsUntilPlay = response.span || response.period || 0;
+        this.account.cw.canPlayAgain = Date.now() + (this.account.cw.secondsUntilPlay * 1000);
+
+        return this.account.cw;
+    }
+
+    async playChiknWinner() {
+        if (this.account.cw.atLimit || this.account.cw.limit > ChiknWinnerDailyLimit) return 'hit_daily_limit';
+        if (this.account.cw.canPlayAgain > Date.now()) return 'on_cooldown';
+
+        const response = await queryServices({
+            cmd: 'incentivizedVideoReward',
+            firebaseId: this.account.firebaseId,
+            id: this.account.id,
+            sessionId: this.account.sessionId,
+            token: null
+        }, this.proxy, this.instance);
+
+        if (response.error) {
+            if (response.error == 'RATELIMITED') {
+                await this.checkChiknWinner();
+                return 'on_cooldown';
+            } else if (response.error == 'SESSION_EXPIRED') {
+                return 'session_expired';
+            } else {
+                console.error('Unknown Chikn Winner response', response);
+                return 'unknown_error';
+            }
+        }
+
+        if (response.reward) {
+            this.account.eggBalance += response.reward.eggsGiven;
+            response.reward.itemIds.forEach((id) => this.account.ownedItemIds.push(id));
+
+            await this.checkChiknWinner();
+
+            return response.reward;
+        }
+
+        console.error('Unknown Chikn Winner response', response);
+        return 'unknown_error';
+    }
+
+    async resetChiknWinner() {
+        if (this.account.eggBalance < 200) return 'not_enough_eggs';
+        if (!this.account.cw.atLimit) return 'not_at_limit';
+
+        const response = await queryServices({
+            cmd: 'chwReset',
+            sessionId: this.account.sessionId
+        });
+
+        if (response.result !== 'SUCCESS') {
+            console.error('Unknown Chikn Winner reset response', response);
+            return 'unknown_error';
+        }
+
+        this.account.eggBalance -= 200;
+        await this.checkChiknWinner();
+
+        return this.account.cw;
+    }
+
+    canSee(target) {
+        if (!this.intents.includes(this.Intents.PATHFINDING)) throw new Error('You must have the PATHFINDING intent to use this method.');
+        return this.pathing.nodeList.hasLineOfSight(this.me.position, target.position);
+    }
+
+    getBestTarget() {
+        const options = Object.values(this.players)
+            .filter((player) => player)
+            .filter((player) => player !== this.me)
+            .filter((player) => player.playing)
+            .filter((player) => player.hp > 0)
+            .filter((player) => player.name !== this.me.name)
+            .filter((player) => this.me.team === 0 || player.team !== this.me.team)
+            .filter((player) => this.canSee(player));
+
+        let minDistance = 200;
+        let targetPlayer = null;
+
+        for (const player of options) {
+            const dx = player.position.x - this.me.position.x;
+            const dy = player.position.y - this.me.position.y;
+            const dz = player.position.z - this.me.position.z;
+
+            const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+            if (distance < minDistance) {
+                minDistance = distance;
+                targetPlayer = player;
+            }
+        }
+
+        return targetPlayer;
+    }
+
+    async refreshBalance() {
+        const result = await queryServices({
+            cmd: 'checkBalance',
+            firebaseId: this.account.firebaseId,
+            sessionId: this.account.sessionId
+        }, this.proxy, this.instance);
+
+        this.account.eggBalance = result.currentBalance;
+
+        return result.currentBalance;
+    }
+
+    async redeemCode(code) {
+        const result = await queryServices({
+            cmd: 'redeem',
+            firebaseId: this.account.firebaseId,
+            sessionId: this.account.sessionId,
+            id: this.account.id,
+            code
+        }, this.proxy, this.instance);
+
+        if (result.result === 'SUCCESS') {
+            this.account.eggBalance = result.eggs_given;
+            result.item_ids.forEach((id) => this.account.ownedItemIds.push(id));
+
+            return {
+                result,
+                eggsGiven: result.eggs_given,
+                itemIds: result.item_ids
+            };
+        } else return result;
+    }
+
+    async claimURLReward(reward) {
+        const result = await queryServices({
+            cmd: 'urlRewardParams',
+            firebaseId: this.account.firebaseId,
+            sessionId: this.account.sessionId,
+            reward
+        }, this.proxy, this.instance);
+
+        if (result.result === 'SUCCESS') {
+            this.account.eggBalance += result.eggsGiven;
+            result.itemIds.forEach((id) => this.account.ownedItemIds.push(id));
+        }
+
+        return result;
+    }
+
+    async claimSocialReward(rewardTag) {
+        const result = await queryServices({
+            cmd: 'reward',
+            firebaseId: this.account.firebaseId,
+            sessionId: this.account.sessionId,
+            rewardTag
+        }, this.proxy, this.instance);
+
+        if (result.result === 'SUCCESS') {
+            this.account.eggBalance += result.eggsGiven;
+            result.itemIds.forEach((id) => this.account.ownedItemIds.push(id));
+        }
+
+        return result;
+    }
+
+    async buyItem(itemId) {
+        const result = await queryServices({
+            cmd: 'buy',
+            firebaseId: this.account.firebaseId,
+            sessionId: this.account.sessionId,
+            itemId,
+            save: true
+        }, this.proxy, this.instance);
+
+        if (result.result === 'SUCCESS') {
+            this.account.eggBalance = result.currentBalance;
+            this.account.ownedItemIds.push(result.itemId);
+        }
+
+        return result;
+    }
+
+    quit(noCleanup = false) {
+        if (this.intents.includes(this.Intents.PLAYER_HEALTH))
+            clearInterval(this.healthIntervalId);
+
+        clearInterval(this.updateIntervalId);
+
+        this.game.socket.close();
+        this.matchmaker.close();
+
+        if (!noCleanup) {
+            delete this.account;
+            delete this.game;
+            delete this.me;
+            delete this.players;
         }
     }
 }