yolkbot 1.4.8 → 1.5.1

package/dist/bot.js

@@ -4,19 +4,13 @@ import CommOut from "./comm/CommOut.js";
 import CloseCode from "./constants/CloseCode.js";
 import CommCode from "./constants/CommCode.js";
 import GamePlayer from "./bot/GamePlayer.js";
-import Matchmaker from "./matchmaker.js";
 import yolkws from "./socket.js";
 import {
   ChiknWinnerDailyLimit,
-  CollectType,
   CoopState,
   findItemById,
   FramesBetweenSyncs,
-  GameAction,
   GameMode,
-  GameOptionFlag,
-  GunList,
-  ItemType,
   Movement,
   PlayType,
   ShellStreak,
@@ -24,57 +18,89 @@ import {
 } from "./constants/index.js";
 import LookAtPosDispatch from "./dispatches/LookAtPosDispatch.js";
 import MovementDispatch from "./dispatches/MovementDispatch.js";
-import globals from "./env/globals.js";
-import { NodeList } from "./pathing/mapnode.js";
-import { coords } from "./wasm/direct.js";
-import { fetchMap, initKotcZones } from "./util.js";
+import { DispatchIndex } from "./dispatches/index.js";
+import { coords, validate } from "./wasm/direct.js";
+import { createError } from "./util.js";
 import { Challenges } from "./constants/challenges.js";
 import { Maps } from "./constants/maps.js";
 import { Regions } from "./constants/regions.js";
-const GameModeById = Object.fromEntries(Object.entries(GameMode).map(([key, value]) => [value, key]));
-const CCGameOptionFlag = Object.fromEntries(Object.entries(GameOptionFlag).map(([k, v]) => [k[0].toLowerCase() + k.slice(1), v]));
-const intents = {
-  CHALLENGES: 1,
-  BOT_STATS: 2,
-  PATHFINDING: 3,
-  PING: 5,
-  COSMETIC_DATA: 6,
-  PLAYER_HEALTH: 7,
-  PACKET_HOOK: 8,
-  LOG_PACKETS: 10,
-  NO_LOGIN: 11,
-  DEBUG_BUFFER: 12,
-  NO_AFK_KICK: 16,
-  LOAD_MAP: 17,
-  OBSERVE_GAME: 18,
-  NO_REGION_CHECK: 19,
-  NO_EXIT_ON_ERROR: 20,
-  RENEW_SESSION: 21,
-  VIP_HIDE_BADGE: 22
-};
+import {
+  BuyItemError,
+  ChallengeClaimError,
+  ChallengeRerollError,
+  ChicknWinnerError,
+  ClaimSocialError,
+  ClaimURLError,
+  CleanupLevel,
+  GameFindError,
+  GameJoinError,
+  Intents,
+  LoginError,
+  MatchmakerError,
+  RedeemCodeError
+} from "./enums.js";
+import processAddPlayerPacket from "./packets/addPlayer.js";
+import processBeginShellStreakPacket from "./packets/beginShellStreak.js";
+import processChallengeCompletedPacket from "./packets/challengeCompleted.js";
+import processChangeCharacterPacket from "./packets/changeCharacter.js";
+import processChatPacket from "./packets/chat.js";
+import processCollectItemPacket from "./packets/collectItem.js";
+import processDiePacket from "./packets/die.js";
+import processEndShellStreakPacket from "./packets/endShellStreak.js";
+import processEventModifierPacket from "./packets/eventModifier.js";
+import processExplodePacket from "./packets/explode.js";
+import processFirePacket from "./packets/fire.js";
+import processGameActionPacket from "./packets/gameAction.js";
+import processGameJoinedPacket from "./packets/gameJoined.js";
+import processGameOptionsPacket from "./packets/gameOptions.js";
+import processHitMeHardBoiledPacket from "./packets/hitMeHardBoiled.js";
+import processHitMePacket from "./packets/hitMe.js";
+import processHitThemPacket from "./packets/hitThem.js";
+import processMeleePacket from "./packets/melee.js";
+import processMetaGameStatePacket from "./packets/metaGameState.js";
+import processPausePacket from "./packets/pause.js";
+import processPingPacket from "./packets/ping.js";
+import processPlayerInfoPacket from "./packets/playerInfo.js";
+import processReloadPacket from "./packets/reload.js";
+import processRemovePlayerPacket from "./packets/removePlayer.js";
+import processRespawnPacket from "./packets/respawn.js";
+import processSocketReadyPacket from "./packets/socketReady.js";
+import processSpawnItemPacket from "./packets/spawnItem.js";
+import processSwitchTeamPacket from "./packets/switchTeam.js";
+import processSyncMePacket from "./packets/syncMe.js";
+import processSyncThemPacket from "./packets/syncThem.js";
+import processThrowGrenadePacket from "./packets/throwGrenade.js";
+import processUpdateBalancePacket from "./packets/updateBalance.js";
+import processSwapWeaponPacket from "./packets/swapWeapon.js";
 const mod = (n, m) => (n % m + m) % m;
 
 export class Bot {
-  static Intents = intents;
-  Intents = intents;
+  intents = [];
+  regionList = [];
+  matchmakerListeners = [];
   #dispatches = [];
   #hooks = {};
   #globalHooks = [];
   #initialAccount;
   #initialGame;
+  errorLogger = (...args) => console.error(...args);
   constructor(params = {}) {
-    if (params.proxy && globals.isBrowser)
-      this.processError("proxies do not work and hence are not supported in the browser");
+    if (params.proxy && typeof process === "undefined")
+      throw new Error("proxies do not work in this environment");
     this.intents = params.intents || [];
-    if (this.intents.includes(this.Intents.COSMETIC_DATA)) {
+    if (this.intents.includes(Intents.COSMETIC_DATA)) {
       const ballCap = findItemById(1001);
       if (!ballCap)
-        this.processError("you cannot use the COSMETIC_DATA intent inside of the singlefile browser bundles");
+        throw new Error("you cannot use the COSMETIC_DATA intent inside of the browser bundles");
     }
+    if (this.intents.includes(Intents.SIMULATION) && !this.intents.includes(Intents.PATHFINDING))
+      throw new Error("the SIMULATION intent requires the PATHFINDING intent");
     this.instance = params.instance || "shellshock.io";
     this.protocol = params.protocol || "wss";
     this.proxy = params.proxy || "";
     this.connectionTimeout = params.connectionTimeout || 5000;
+    if (typeof params.errorLogger === "function")
+      this.errorLogger = params.errorLogger;
     this.state = {
       name: "yolkbot",
       weaponIdx: 0,
@@ -84,23 +110,27 @@ export class Bot {
       yaw: 0,
       pitch: 0,
       controlKeys: 0,
+      onGround: 4,
+      dx: 0,
+      dy: 0,
+      dz: 0,
       reloading: false,
       swappingGun: false,
       usingMelee: false,
       stateIdx: 0,
       serverStateIdx: 0,
       shotsFired: 0,
-      buffer: [],
-      left: false
+      buffer: []
     };
     this.players = {};
     this.me = new GamePlayer({});
     this.game = {
       raw: {},
       code: "",
+      region: "",
       socket: null,
       gameModeId: 0,
-      gameMode: GameModeById[0],
+      gameMode: "ffa",
       mapIdx: 0,
       map: {
         filename: "",
@@ -115,7 +145,6 @@ export class Bot {
         availability: "both",
         numPlayers: "18",
         raw: {},
-        nodes: {},
         zones: []
       },
       playerLimit: 0,
@@ -131,22 +160,24 @@ export class Bot {
         weaponsDisabled: Array(7).fill(false),
         mustUseSecondary: false
       },
-      collectables: [[], []],
+      collectibles: [[], []],
       teamScore: [0, 0, 0],
       spatula: {
         coords: { x: 0, y: 0, z: 0 },
         controlledBy: 0,
         controlledByTeam: 0
       },
-      stage: CoopState.Capturing,
-      zoneNumber: 0,
-      activeZone: [],
-      capturing: 0,
-      captureProgress: 0,
-      numCapturing: 0,
-      capturePercent: 0
+      kotc: {
+        stage: CoopState.Capturing,
+        zoneIdx: 0,
+        activeZone: [],
+        teamCapturing: 0,
+        captureProgress: 0,
+        numCapturing: 0,
+        capturePercent: 0
+      }
     };
-    this.#initialGame = this.game;
+    this.#initialGame = JSON.parse(JSON.stringify(this.game));
     this.account = {
       id: 0,
       firebase: {
@@ -173,15 +204,7 @@ export class Bot {
         classIdx: 0,
         colorIdx: 0,
         grenadeId: 0,
-        primaryId: [
-          3100,
-          3600,
-          3400,
-          3800,
-          4000,
-          4200,
-          4500
-        ],
+        primaryId: [3100, 3600, 3400, 3800, 4000, 4200, 4500],
         secondaryId: new Array(7).fill(3000),
         stampPositionX: 0,
         stampPositionY: 0
@@ -190,42 +213,34 @@ export class Bot {
       vip: false,
       emailVerified: false,
       isAged: false,
-      eggBalance: 0,
+      isCG: false,
       adminRoles: 0,
       rawLoginData: {},
-      isDoubleEggWeeknd: () => {
-        const day = new Date().getUTCDay();
-        const hours = new Date().getUTCHours();
-        return day >= 5 && hours >= 20 || day === 6 || day === 0;
-      }
+      eggBalance: 0
     };
-    this.#initialAccount = this.account;
-    this.matchmaker = null;
+    this.#initialAccount = JSON.parse(JSON.stringify(this.account));
     this.api = new API({
       proxy: this.proxy,
       protocol: this.protocol,
       instance: this.instance,
-      maxRetries: params?.apiMaxRetries,
       connectionTimeout: this.connectionTimeout
     });
     this.ping = 0;
     this.lastPingTime = -1;
     this.lastDeathTime = -1;
-    this.lastUpdateTick = 0;
     this.pathing = {
       nodeList: null,
-      followingPath: false,
       activePath: null,
       activeNode: null,
       activeNodeIdx: 0
     };
     this.hasQuit = false;
-    if (this.intents.includes(this.Intents.NO_AFK_KICK))
+    if (this.intents.includes(Intents.NO_AFK_KICK))
       this.afkKickInterval = 0;
-    if (this.intents.includes(this.Intents.RENEW_SESSION))
+    if (this.intents.includes(Intents.RENEW_SESSION))
       this.renewSessionInterval = 0;
   }
-  dispatch(dispatch) {
+  dispatch(dispatch, isEmit) {
     if (dispatch.validate(this)) {
       if (dispatch.check(this))
         dispatch.execute(this);
@@ -233,6 +248,9 @@ export class Bot {
         this.#dispatches.push(dispatch);
       return true;
     }
+    this.errorLogger(`${isEmit ? "emit" : "dispatch"}: validation failed for dispatch ${dispatch.constructor.name}`);
+    this.errorLogger("this means the dispatch will NEVER RUN!");
+    this.errorLogger("make sure all parameters are valid and that any player IDs are in the game");
     return false;
   }
   async createAccount(email, pass) {
@@ -260,53 +278,49 @@ export class Bot {
     return this.processLoginData(loginData);
   }
   processLoginData(loginData) {
-    if (typeof loginData !== "object") {
-      this.emit("authFail", loginData);
-      return loginData;
+    if (!loginData.ok || !loginData.playerOutput) {
+      this.$emit("authFail", loginData);
+      if (loginData.ok && !loginData.playerOutput)
+        this.errorLogger("processLoginData: missing playerOutput but is ok", loginData);
+      return { ...loginData, error: LoginError.InternalError, ok: false };
     }
     if (loginData.banRemaining) {
-      this.emit("banned", loginData.banRemaining);
-      return "account_banned";
+      this.$emit("banned", loginData.banRemaining);
+      return createError(LoginError.AccountBanned);
     }
-    if (!loginData.playerOutput) {
-      this.emit("authFail", loginData);
-      return loginData;
-    }
-    this.account.firebase = loginData.firebase || {};
-    loginData = loginData.playerOutput;
-    this.account.rawLoginData = loginData;
-    this.account.adminRoles = loginData.adminRoles || 0;
-    this.account.eggBalance = loginData.currentBalance;
-    this.account.emailVerified = loginData.emailVerified;
-    this.account.firebaseId = loginData.firebaseId;
-    this.account.id = loginData.id;
-    this.account.isAged = new Date(loginData.dateCreated).getTime() < 1714546800000;
-    this.account.loadout = loginData.loadout;
-    this.account.ownedItemIds = loginData.ownedItemIds;
-    this.account.session = loginData.session;
-    this.account.sessionId = loginData.sessionId;
-    this.account.vip = loginData.active_sub === "IsVIP";
-    if (this.intents.includes(this.Intents.BOT_STATS))
+    this.account.firebase = loginData.firebase;
+    const output = loginData.playerOutput;
+    this.account.rawLoginData = output;
+    this.account.adminRoles = output.adminRoles || 0;
+    this.account.eggBalance = output.currentBalance;
+    this.account.emailVerified = output.emailVerified;
+    this.account.firebaseId = output.firebaseId;
+    this.account.id = output.id;
+    this.account.isAged = new Date(output.dateCreated).getTime() < 1714546800000;
+    this.account.isCG = output.cgAccountStatus?.hasAccount;
+    this.account.loadout = output.loadout;
+    this.account.ownedItemIds = output.ownedItemIds;
+    this.account.session = output.session;
+    this.account.sessionId = output.sessionId;
+    this.account.vip = output.active_sub === "IsVIP";
+    if (this.intents.includes(Intents.BOT_STATS))
       this.account.stats = {
-        lifetime: loginData.statsLifetime,
-        monthly: loginData.statsCurrent
+        lifetime: output.statsLifetime,
+        monthly: output.statsCurrent
       };
-    if (this.intents.includes(this.Intents.CHALLENGES))
-      this.#importChallenges(loginData.challenges);
-    this.emit("authSuccess", this.account);
-    if (this.intents.includes(this.Intents.RENEW_SESSION)) {
+    if (this.intents.includes(Intents.CHALLENGES))
+      this.#importChallenges(output.challenges);
+    this.$emit("authSuccess", this.account);
+    if (this.intents.includes(Intents.RENEW_SESSION)) {
       this.renewSessionInterval = setInterval(async () => {
         if (!this.account?.sessionId)
           return clearInterval(this.renewSessionInterval);
-        const res = await this.api.queryServices({
-          cmd: "renewSession",
-          sessionId: this.account.sessionId
-        });
+        const res = await this.api.queryServices({ cmd: "renewSession", sessionId: this.account.sessionId });
         if (res.data !== "renewed")
-          this.emit("sessionExpired");
-      }, 600000);
+          this.$emit("sessionExpired");
+      }, 10 * 60 * 1000);
     }
-    return this.account;
+    return { ok: true, account: this.account };
   }
   #importChallenges(challengeArray) {
     this.account.challenges = [];
@@ -329,213 +343,333 @@ export class Bot {
       });
     }
   }
-  async initMatchmaker() {
-    if (!this.account.sessionId && !this.intents.includes(this.Intents.NO_LOGIN)) {
+  async createMatchmaker() {
+    const matchmaker = new yolkws(`${this.protocol}://${this.instance}/matchmaker/`, { proxy: this.proxy, errorLogger: this.errorLogger });
+    matchmaker.autoReconnect = true;
+    const didConnect = await matchmaker.tryConnect();
+    if (!didConnect)
+      return createError(MatchmakerError.WebSocketConnectFail);
+    this.matchmaker = matchmaker;
+    const uuidTimeouts = [];
+    this.matchmaker.onmessage = async (e) => {
+      const data = JSON.parse(e.data);
+      if (data.command === "validateUUID") {
+        const timeout = setTimeout(() => {
+          console.error("createMatchmaker: the matchmaker did not respond to our validateUUID");
+          console.error("createMatchmaker: this means yolkbot is broken, please report this on Github");
+          console.error("createMatchmaker: https://github.com/yolkorg/yolkbot (or join the Discord)");
+        }, 5000);
+        uuidTimeouts.push(timeout);
+        return this.matchmaker.send(JSON.stringify({ command: "validateUUID", hash: await validate(data.uuid) }));
+      }
+      if (uuidTimeouts.length) {
+        uuidTimeouts.forEach((t) => clearTimeout(t));
+        uuidTimeouts.length = 0;
+      }
+      this.matchmakerListeners.forEach((listener) => listener(data));
+    };
+    return { ok: true };
+  }
+  async getRegions() {
+    if (!this.matchmaker) {
+      const mmConnection = await this.createMatchmaker();
+      if (!mmConnection.ok)
+        return mmConnection;
+    }
+    return new Promise((res) => {
+      const listener = (data) => {
+        if (data.command === "regionList") {
+          this.matchmakerListeners.splice(this.matchmakerListeners.indexOf(listener), 1);
+          this.regionList = data.regionList;
+          res({ ok: true, regionList: this.regionList });
+        }
+      };
+      this.matchmakerListeners.push(listener);
+      this.matchmaker.send(JSON.stringify({ command: "regionList" }));
+    });
+  }
+  async initSession() {
+    if (!this.account.sessionId && !this.intents.includes(Intents.SKIP_LOGIN)) {
       const anonLogin = await this.loginAnonymously();
-      if (typeof anonLogin !== "object")
+      if (!anonLogin.ok)
         return anonLogin;
     }
     if (!this.matchmaker) {
-      this.matchmaker = new Matchmaker({
-        api: this.api,
-        proxy: this.proxy,
-        protocol: this.protocol,
-        instance: this.instance,
-        sessionId: this.account.sessionId,
-        connectionTimeout: this.connectionTimeout,
-        noLogin: this.intents.includes(this.Intents.NO_LOGIN)
-      });
-      const didConnect = await this.matchmaker.ws.tryConnect();
-      if (!didConnect)
-        return "matchmaker_tryconnect_failed";
-      this.matchmaker.on("authFail", (data) => this.emit("authFail", data));
-      this.matchmaker.on("error", (data) => this.processError(data));
+      const mmConnection = await this.createMatchmaker();
+      if (!mmConnection.ok)
+        return mmConnection;
     }
-    return true;
+    return { ok: true };
   }
-  async findPublicGame(region, modeId) {
+  async findPublicGame(region, mode) {
     if (typeof region !== "string")
-      return "no_region_passed";
-    if (!Regions.find((r) => r.id === region) && !this.intents.includes(this.Intents.NO_REGION_CHECK))
-      return "invalid_region_passed";
-    if (typeof modeId !== "number")
-      return "no_mode_passed";
-    if (Object.values(GameMode).indexOf(modeId) === -1)
-      return "invalid_mode_passed";
-    if (!await this.initMatchmaker())
-      return "matchmaker_init_fail";
+      return createError(GameFindError.MissingParams);
+    const regions = this.regionList.length ? this.regionList : Regions;
+    if (!regions.find((r) => r.id === region))
+      return createError(GameFindError.InvalidRegion);
+    let computedModeId;
+    if (typeof mode === "number") {
+      if (Object.values(GameMode).indexOf(mode) > -1)
+        computedModeId = mode;
+      else
+        return createError(GameFindError.InvalidMode);
+    } else if (typeof mode === "string") {
+      const modeEntry = Object.keys(GameMode).find((key) => key.toLowerCase() === mode.toLowerCase());
+      if (modeEntry)
+        computedModeId = GameMode[modeEntry];
+      else
+        return createError(GameFindError.InvalidMode);
+    } else
+      return createError(GameFindError.InvalidMode);
+    const initInfo = await this.initSession();
+    if (!initInfo.ok)
+      return initInfo;
     const game = await new Promise((resolve) => {
       const listener = (msg) => {
         if (msg.command === "notice")
           return;
-        this.matchmaker.off("msg", listener);
+        this.matchmakerListeners.splice(this.matchmakerListeners.indexOf(listener), 1);
         if (msg.command === "gameFound") {
           if (msg.useAltGameURL)
             this.state.useAltGameURL = true;
           return resolve(msg);
         }
         if (msg.error === "sessionNotFound")
-          return resolve("internal_session_error");
-        this.processError("unknown matchmaker response", JSON.stringify(msg));
+          return resolve(createError(GameFindError.SessionExpired));
+        this.errorLogger("findPublicGame: unknown matchmaker response", JSON.stringify(msg));
+        resolve(createError(GameFindError.InternalError));
       };
-      this.matchmaker.on("msg", listener);
-      this.matchmaker.send({
+      this.matchmakerListeners.push(listener);
+      this.matchmaker.send(JSON.stringify({
         command: "findGame",
         region,
         playType: PlayType.JoinPublic,
-        gameType: modeId,
+        gameType: computedModeId,
         sessionId: this.account.sessionId
-      });
+      }));
     });
-    return game;
+    if (!game.ok)
+      return game;
+    return {
+      ok: true,
+      raw: game,
+      id: game.id,
+      uuid: game.uuid,
+      region: game.region,
+      private: game.private,
+      subdomain: game.subdomain
+    };
   }
-  async createPrivateGame(region, modeId, map) {
+  async createPrivateGame(region, mode, map) {
     if (typeof region !== "string")
-      return "no_region_passed";
-    if (!Regions.find((r) => r.id === region) && !this.intents.includes(this.Intents.NO_REGION_CHECK))
-      return "invalid_region_passed";
-    if (typeof modeId !== "number")
-      return "no_mode_passed";
-    if (Object.values(GameMode).indexOf(modeId) === -1)
-      return "invalid_mode_passed";
-    if (typeof map !== "string")
-      return "no_map_passed";
+      return createError(GameFindError.MissingParams);
+    const regions = this.regionList.length ? this.regionList : Regions;
+    if (!regions.find((r) => r.id === region))
+      return createError(GameFindError.InvalidRegion);
+    let computedModeId;
+    if (typeof mode === "number") {
+      if (Object.values(GameMode).indexOf(mode) > -1)
+        computedModeId = mode;
+      else
+        return createError(GameFindError.InvalidMode);
+    } else if (typeof mode === "string") {
+      const modeEntry = Object.keys(GameMode).find((key) => key.toLowerCase() === mode.toLowerCase());
+      if (modeEntry)
+        computedModeId = GameMode[modeEntry];
+      else
+        return createError(GameFindError.InvalidMode);
+    } else
+      return createError(GameFindError.InvalidMode);
     const mapIdx = Maps.findIndex((m) => m.name.toLowerCase() === map.toLowerCase());
     if (mapIdx === -1)
-      return "invalid_map_passed";
-    if (!await this.initMatchmaker())
-      return "matchmaker_init_fail";
+      return createError(GameFindError.InvalidMap);
+    const initInfo = await this.initSession();
+    if (!initInfo.ok)
+      return initInfo;
     const game = await new Promise((resolve) => {
       const listener = (msg) => {
         if (msg.command === "notice")
           return;
-        this.matchmaker.off("msg", listener);
+        this.matchmakerListeners.splice(this.matchmakerListeners.indexOf(listener), 1);
         if (msg.command === "gameFound") {
           if (msg.useAltGameURL)
             this.state.useAltGameURL = true;
           return resolve(msg);
         }
         if (msg.error === "sessionNotFound")
-          return resolve("internal_session_error");
-        this.processError("unknown matchmaker response", JSON.stringify(msg));
+          return resolve(createError(GameFindError.SessionExpired));
+        this.errorLogger("createPrivateGame: unknown matchmaker response", JSON.stringify(msg));
+        resolve(createError(GameFindError.InternalError));
       };
-      this.matchmaker.on("msg", listener);
-      this.matchmaker.send({
+      this.matchmakerListeners.push(listener);
+      this.matchmaker.send(JSON.stringify({
         command: "findGame",
         region,
         playType: PlayType.CreatePrivate,
-        gameType: modeId,
+        gameType: computedModeId,
         sessionId: this.account.sessionId,
         noobLobby: false,
         map: mapIdx
-      });
+      }));
     });
-    return game;
+    if (!game.ok)
+      return game;
+    return {
+      ok: true,
+      raw: game,
+      id: game.id,
+      uuid: game.uuid,
+      region: game.region,
+      private: game.private,
+      subdomain: game.subdomain
+    };
   }
   async join(name, data) {
     this.state.name = name || "yolkbot";
     if (typeof data === "string") {
       if (data.includes("#"))
         data = data.split("#")[1];
-      if (!await this.initMatchmaker())
-        return "matchmaker_init_fail";
+      const initInfo = await this.initSession();
+      if (!initInfo.ok)
+        return initInfo;
       const joinResult = await new Promise((resolve) => {
         const listener = (message) => {
           if (message.command === "gameFound") {
-            this.matchmaker.off("msg", listener);
+            this.matchmakerListeners.splice(this.matchmakerListeners.indexOf(listener), 1);
             this.game.raw = message;
             this.game.code = message.id;
+            this.game.region = message.region;
             resolve(message.id);
           }
           if (message.error && message.error === "gameNotFound") {
-            this.processError(`game "${data}" not found, it may have expired.`);
-            this.leave();
-            return "gameNotFound";
+            this.matchmakerListeners.splice(this.matchmakerListeners.indexOf(listener), 1);
+            resolve("gameNotFound");
           }
         };
-        this.matchmaker.on("msg", listener);
-        this.matchmaker.send({
+        this.matchmakerListeners.push(listener);
+        this.matchmaker.send(JSON.stringify({
           command: "joinGame",
           id: data,
           observe: false,
           sessionId: this.account.sessionId
-        });
+        }));
       });
       if (joinResult === "gameNotFound")
-        return "game_not_found";
-      if (!this.game.raw.id)
-        return this.processError("an internal error occured while joining the game, please report this to developers");
-    }
-    if (typeof data === "object") {
-      if (this.account.id === 0)
-        await this.loginAnonymously();
+        return createError(GameJoinError.GameNotFound);
+      if (!this.game.raw.id) {
+        this.errorLogger("join: invalid game data received from matchmaker:", this.game.raw);
+        return createError(GameJoinError.InternalError);
+      }
+    } else if (typeof data === "object") {
+      if (!data.id || !data.subdomain || !data.uuid || !data.region)
+        return createError(GameJoinError.InvalidObject);
+      if (this.account.id === 0) {
+        const anonAttempt = await this.loginAnonymously();
+        if (!anonAttempt.ok)
+          return anonAttempt;
+      }
       this.game.raw = data;
       this.game.code = this.game.raw.id;
-      if (!this.game.raw.id)
-        return "invalid_game_object";
-      if (!this.game.raw.subdomain)
-        return "invalid_game_object";
-      if (!this.game.raw.uuid)
-        return "invalid_game_object";
-      if (data.useAltGameURL)
-        this.state.useAltGameURL = true;
-    }
-    const host = this.state.useAltGameURL || this.host === "proxy.yolkbot.xyz" ? `${this.instance}/servers/${this.game.raw.subdomain}` : `${this.game.raw.subdomain}.${this.instance}`;
-    this.game.socket = new yolkws(`${this.protocol}://${host}/game/${this.game.raw.id}`, this.proxy);
+      this.game.region = this.game.raw.region;
+    } else
+      return createError(GameJoinError.MissingParams);
+    const host = this.state.useAltGameURL || this.instance === "proxy.yolkbot.xyz" ? `${this.instance}/servers/${this.game.raw.subdomain}` : `${this.game.raw.subdomain}.${this.instance}`;
+    this.game.socket = new yolkws(`${this.protocol}://${host}/game/${this.game.raw.id}`, { proxy: this.proxy, errorLogger: this.errorLogger });
     this.game.socket.binaryType = "arraybuffer";
     this.game.socket.connectionTimeout = this.connectionTimeout;
     this.game.socket.onBeforeConnect = () => {
       this.game.socket.onmessage = (msg) => this.processPacket(msg.data);
       this.game.socket.onclose = (e) => {
-        if (this.state.left)
-          this.state.left = false;
-        else {
-          this.emit("close", e.code);
+        if (this.state?.inGame) {
+          this.$emit("close", e.code);
           this.leave(-1);
         }
       };
     };
     const didConnect = await this.game.socket.tryConnect();
     if (!didConnect)
-      return "websocket_tryconnect_fail";
-    return true;
+      return createError(GameJoinError.WebSocketConnectFail);
+    return { ok: true };
+  }
+  #processMovement(ndx, ndy, ndz) {
+    this.state.onGround = Math.max(--this.state.onGround, 0);
+    this.me.position.x += ndx;
+    this.me.position.y += ndy;
+    this.me.position.z += ndz;
+    const thisBlockX = Math.floor(this.me.position.x);
+    const thisBlockY = Math.floor(this.me.position.y);
+    const thisBlockZ = Math.floor(this.me.position.z);
+    const blockInMyHitbox = this.pathing.nodeList.at(thisBlockX, thisBlockY, thisBlockZ);
+    if (blockInMyHitbox && !blockInMyHitbox.isAir()) {
+      if (!this.climbing && blockInMyHitbox.isLadder()) {}
+    }
+    if (this.me.climbing) {} else if (blockInMyHitbox && blockInMyHitbox.isJumpPad()) {
+      this.me.position.y += 0.26;
+      this.me.jumping = true;
+      this.state.onGround = 0;
+    }
   }
   #processPathfinding() {
-    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) {
-      this.pathing.followingPath = false;
+    const pathLen = this.pathing.activePath.length;
+    const lastNode = this.pathing.activePath[pathLen - 1];
+    const myPos = this.me.position;
+    const myFloorY = Math.floor(myPos.y);
+    const distToEndCenter = Math.hypot(myPos.x - lastNode.flatCenter.x, myPos.z - lastNode.flatCenter.z);
+    if (distToEndCenter < 0.3) {
       this.pathing.activePath = null;
       this.pathing.activeNode = null;
       this.pathing.activeNodeIdx = 0;
       this.dispatch(new MovementDispatch(0));
+      this.$emit("pathfindComplete");
     } 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));
+      let shouldJump = false;
+      if (this.pathing.activeNodeIdx < pathLen - 1) {
+        const currentNode = this.pathing.activePath[this.pathing.activeNodeIdx];
+        const nextNode = this.pathing.activePath[this.pathing.activeNodeIdx + 1];
+        const dx = Math.abs(currentNode.x - nextNode.x);
+        const dz = Math.abs(currentNode.z - nextNode.z);
+        const isParkourJump = dx === 2 && dz === 0 || dx === 0 && dz === 2 || dx === 2 && dz === 1 || dx === 1 && dz === 2 || dx === 2 && dz === 2;
+        if (isParkourJump) {
+          const localX = myPos.x - Math.floor(myPos.x);
+          const localZ = myPos.z - Math.floor(myPos.z);
+          const headingX = nextNode.x > currentNode.x ? 1 : nextNode.x < currentNode.x ? -1 : 0;
+          const headingZ = nextNode.z > currentNode.z ? 1 : nextNode.z < currentNode.z ? -1 : 0;
+          let distToEdge = 0;
+          if (headingX > 0)
+            distToEdge = 1 - localX;
+          else if (headingX < 0)
+            distToEdge = localX;
+          else if (headingZ > 0)
+            distToEdge = 1 - localZ;
+          else if (headingZ < 0)
+            distToEdge = localZ;
+          if (distToEdge <= 0.04)
+            shouldJump = true;
+        }
       }
-      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;
-          }
+      if (this.pathing.activeNodeIdx < pathLen) {
+        const positionTarget = this.pathing.activePath[this.pathing.activeNodeIdx].flatCenter;
+        if (this.state.onGround)
+          this.dispatch(new LookAtPosDispatch(positionTarget));
+      }
+      for (let i = this.pathing.activeNodeIdx;i < pathLen; i++) {
+        const node = this.pathing.activePath[i];
+        if (node.flatRadialDistance(myPos) < 0.1 && node.y === myFloorY) {
+          this.pathing.activeNodeIdx = i + 1;
+          this.pathing.activeNode = this.pathing.activePath[this.pathing.activeNodeIdx];
+          break;
         }
       }
-      if (!(this.state.controlKeys & Movement.Forward))
-        this.dispatch(new MovementDispatch(Movement.Forward));
+      const movementKeys = Movement.Forward | (shouldJump ? Movement.Jump : 0);
+      this.dispatch(new MovementDispatch(movementKeys));
     }
   }
   update() {
     if (this.hasQuit)
       return;
-    if (this.pathing.followingPath && this.intents.includes(this.Intents.PATHFINDING))
+    if (this.pathing.activePath && this.intents.includes(Intents.PATHFINDING))
       this.#processPathfinding();
-    for (let i = 0;i < this.#dispatches.length; i++) {
+    for (let i = this.#dispatches.length - 1;i >= 0; i--) {
       const disp = this.#dispatches[i];
       if (disp.check(this)) {
         disp.execute(this);
@@ -545,25 +679,99 @@ export class Bot {
     this.state.chatLines = Math.max(0, this.state.chatLines - 1 / (30 * 4));
     if (this.me.playing) {
       const currentIdx = this.state.stateIdx;
-      if (this.intents.includes(this.Intents.DEBUG_BUFFER)) {
+      const isBufferDebug = this.intents.includes(Intents.DEBUG_BUFFER);
+      if (isBufferDebug)
         console.log("setting buffer for idx", currentIdx);
-        console.log("checking...shotsFired", this.state.shotsFired);
-      }
       this.me.jumping = !!(this.state.controlKeys & Movement.Jump);
       this.state.buffer[currentIdx] = {
         controlKeys: this.state.controlKeys,
         yaw: this.state.yaw,
         pitch: this.state.pitch,
-        shotsFired: this.state.shotsFired
+        shotsFired: this.state.shotsFired,
+        position: isBufferDebug ? { ...this.me.position } : {}
       };
       this.state.shotsFired = 0;
-      if (this.lastUpdateTick >= 2) {
-        this.emit("tick");
+      if (this.intents.includes(Intents.SIMULATION)) {
+        let dx = 0;
+        let dy = 0;
+        let dz = 0;
+        const state = this.state.buffer[currentIdx];
+        if (state.controlKeys & Movement.Left) {
+          dx -= Math.cos(state.yaw);
+          dz += Math.sin(state.yaw);
+        }
+        if (state.controlKeys & Movement.Right) {
+          dx += Math.cos(state.yaw);
+          dz -= Math.sin(state.yaw);
+        }
+        if (state.controlKeys & Movement.Forward) {
+          if (this.me.climbing)
+            dy += 1;
+          else {
+            dx -= Math.sin(state.yaw);
+            dz -= Math.cos(state.yaw);
+          }
+        }
+        if (state.controlKeys & Movement.Backward) {
+          if (this.me.climbing)
+            dy -= 1;
+          else {
+            dx += Math.sin(state.yaw);
+            dz += Math.cos(state.yaw);
+          }
+        }
+        if (state.controlKeys & Movement.Jump)
+          this.state.controlKeys ^= this.state.controlKeys & Movement.Jump;
+        if (this.me.climbing) {
+          this.me.jumping = false;
+          dy += dy * 0.028;
+          this.me.position.y += dy;
+          dy *= 0.5;
+          this.#processMovement(0, dy, 0);
+        } else {
+          const mag = Math.sqrt(dx * dx + dy * dy + dz * dz);
+          if (mag > 0) {
+            const normDx = dx / mag;
+            const normDz = dz / mag;
+            dx = this.state.dx + normDx * 0.025;
+            dz = this.state.dz + normDz * 0.025;
+          } else {
+            dx = this.state.dx;
+            dz = this.state.dz;
+          }
+          dy = this.state.dy - this.game.options.gravity * 0.012;
+          dy = Math.max(-0.29, dy);
+          const oldX = this.me.position.x;
+          const oldY = this.me.position.y;
+          const oldZ = this.me.position.z;
+          this.#processMovement(dx, dy, dz);
+          dx = this.me.position.x - oldX;
+          dy = this.me.position.y - oldY;
+          dz = this.me.position.z - oldZ;
+          if (this.state.onGround && dy > 0) {
+            const normY = mag === 0 ? 0 : dy / mag;
+            const n = 1 - normY * 0.5;
+            dx *= n;
+            dz *= n;
+          }
+        }
+        dx *= 0.64;
+        dz *= 0.64;
+        if (this.me.climbing)
+          dy *= 0.64;
+        this.state.dx = dx;
+        this.state.dy = dy;
+        this.state.dz = dz;
+      }
+      if (this.state.stateIdx % FramesBetweenSyncs === 0) {
+        this.$emit("tick");
         const out = new CommOut;
         out.packInt8(CommCode.syncMe);
         out.packInt8(this.state.stateIdx);
         out.packInt8(this.state.serverStateIdx);
         const startIdx = mod(this.state.stateIdx - FramesBetweenSyncs + 1, StateBufferSize);
+        if (isBufferDebug)
+          console.log("--- START THIS SYNC LOGGING ---");
         for (let i = 0;i < FramesBetweenSyncs; i++) {
           const idx = mod(startIdx + i, StateBufferSize);
           const frame = this.state.buffer[idx] || {};
@@ -571,28 +779,30 @@ export class Bot {
           const shots = frame.shotsFired || 0;
           const yaw = frame.yaw ?? this.state.yaw;
           const pitch = frame.pitch ?? this.state.pitch;
-          if (this.intents.includes(this.Intents.DEBUG_BUFFER))
-            console.log("going with", this.state.stateIdx, startIdx, idx, frame);
+          if (isBufferDebug)
+            console.log("adding", this.state.stateIdx, startIdx, idx, frame);
           out.packInt8(keys);
           out.packInt8(shots);
           out.packString(coords(yaw, pitch));
           out.packInt8(100);
         }
         out.send(this.game.socket);
+        if (isBufferDebug)
+          console.log("--- END SYNC LOGGING ---");
         this.state.buffer = [];
-        this.lastUpdateTick = 0;
-      } else
-        this.lastUpdateTick++;
+      }
       this.state.stateIdx = mod(this.state.stateIdx + 1, StateBufferSize);
     }
-    if (!this.intents.includes(this.Intents.PLAYER_HEALTH))
+    if (!this.intents.includes(Intents.PLAYER_HEALTH))
       return;
     const regen = 0.1 * (this.game.isPrivate ? this.game.options.healthRegen : 1);
-    for (const player of Object.values(this.players)) {
+    const players = Object.values(this.players);
+    for (let i = 0;i < players.length; i++) {
+      const player = players[i];
       if (player.playing && player.hp > 0) {
-        const overHeal = player.streakRewards.includes(ShellStreak.OverHeal);
-        player.hp += overHeal ? -regen : regen;
-        player.hp = overHeal ? Math.max(100, player.hp) : Math.min(100, player.hp);
+        const hasOverHeal = player.streakRewards.includes(ShellStreak.OverHeal);
+        player.hp += hasOverHeal ? -regen : regen;
+        player.hp = hasOverHeal ? Math.max(100, player.hp) : Math.min(100, player.hp);
       }
       if (player.spawnShield > 0)
         player.spawnShield -= 6;
@@ -604,13 +814,6 @@ export class Bot {
     else
       this.#hooks[event] = [cb];
   }
-  once(event, cb) {
-    const onceCb = (...args) => {
-      cb(...args);
-      this.off(event, onceCb);
-    };
-    this.on(event, onceCb);
-  }
   onAny(cb) {
     this.#globalHooks.push(cb);
   }
@@ -620,7 +823,7 @@ export class Bot {
     else
       this.#hooks[event] = [];
   }
-  emit(event, ...args) {
+  $emit(event, ...args) {
     if (this.hasQuit)
       return;
     if (this.#hooks[event])
@@ -629,589 +832,12 @@ export class Bot {
     for (const cb of this.#globalHooks)
       cb(event, ...args);
   }
-  #processChatPacket() {
-    const id = CommIn.unPackInt8U();
-    const msgFlags = CommIn.unPackInt8U();
-    const text = CommIn.unPackString().valueOf();
-    const player = this.players[id];
-    this.emit("chat", player, text, msgFlags);
-  }
-  #processAddPlayerPacket() {
-    const id = CommIn.unPackInt8U();
-    const findCosmetics = this.intents.includes(this.Intents.COSMETIC_DATA);
-    const playerData = {
-      id,
-      uniqueId: CommIn.unPackString(),
-      name: CommIn.unPackString(),
-      safeName: CommIn.unPackString(),
-      charClass: CommIn.unPackInt8U(),
-      team: CommIn.unPackInt8U(),
-      primaryWeaponItem: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
-      secondaryWeaponItem: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
-      shellColor: CommIn.unPackInt8U(),
-      hatItem: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
-      stampItem: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
-      stampPosX: CommIn.unPackInt8(),
-      stampPosY: CommIn.unPackInt8(),
-      grenadeItem: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
-      meleeItem: findCosmetics ? findItemById(CommIn.unPackInt16U()) : CommIn.unPackInt16U(),
-      x: CommIn.unPackFloat(),
-      y: CommIn.unPackFloat(),
-      z: CommIn.unPackFloat(),
-      $dx: CommIn.unPackFloat(),
-      $dy: CommIn.unPackFloat(),
-      $dz: CommIn.unPackFloat(),
-      yaw: CommIn.unPackRadU(),
-      pitch: CommIn.unPackRad(),
-      score: CommIn.unPackInt32U(),
-      $kills: CommIn.unPackInt16U(),
-      $deaths: CommIn.unPackInt16U(),
-      $streak: CommIn.unPackInt16U(),
-      totalKills: CommIn.unPackInt32U(),
-      totalDeaths: CommIn.unPackInt32U(),
-      bestStreak: CommIn.unPackInt16U(),
-      $bestOverallStreak: CommIn.unPackInt16U(),
-      shield: CommIn.unPackInt8U(),
-      hp: CommIn.unPackInt8U(),
-      playing: CommIn.unPackInt8U(),
-      weaponIdx: CommIn.unPackInt8U(),
-      $controlKeys: CommIn.unPackInt8U(),
-      upgradeProductId: CommIn.unPackInt8U(),
-      activeShellStreaks: CommIn.unPackInt8U(),
-      social: CommIn.unPackLongString(),
-      hideBadge: CommIn.unPackInt8U()
-    };
-    this.game.mapIdx = CommIn.unPackInt8U();
-    this.game.isPrivate = CommIn.unPackInt8U() === 1;
-    this.game.gameModeId = CommIn.unPackInt8U();
-    const player = new GamePlayer(playerData, this.game.gameMode === GameMode.KOTC ? this.game.activeZone : null);
-    if (!this.players[playerData.id])
-      this.players[playerData.id] = player;
-    this.emit("playerJoin", player);
-    if (this.me.id === playerData.id) {
-      this.me = player;
-      this.emit("botJoin", this.me);
-    }
-  }
-  #processRespawnPacket() {
-    const id = CommIn.unPackInt8U();
-    const seed = CommIn.unPackInt16U();
-    const x = CommIn.unPackFloat();
-    const y = CommIn.unPackFloat();
-    const z = CommIn.unPackFloat();
-    const rounds0 = CommIn.unPackInt8U();
-    const store0 = CommIn.unPackInt8U();
-    const rounds1 = CommIn.unPackInt8U();
-    const store1 = CommIn.unPackInt8U();
-    const grenades = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (player) {
-      player.playing = true;
-      player.randomSeed = seed;
-      if (player.weapons[0] && player.weapons[0].ammo)
-        player.weapons[0].ammo.rounds = rounds0;
-      if (player.weapons[0] && player.weapons[0].ammo)
-        player.weapons[0].ammo.store = store0;
-      if (player.weapons[1] && player.weapons[1].ammo)
-        player.weapons[1].ammo.rounds = rounds1;
-      if (player.weapons[1] && player.weapons[1].ammo)
-        player.weapons[1].ammo.store = store1;
-      player.grenades = grenades;
-      player.position = { x, y, z };
-      player.spawnShield = 120;
-      this.emit("playerRespawn", player);
-    }
-  }
-  #processSyncThemPacket() {
-    const id = CommIn.unPackInt8U();
-    const x = CommIn.unPackFloat();
-    const y = CommIn.unPackFloat();
-    const z = CommIn.unPackFloat();
-    const climbing = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (!player || player.id === this.me.id) {
-      for (let i2 = 0;i2 < FramesBetweenSyncs; i2++) {
-        CommIn.unPackInt8U();
-        CommIn.unPackRadU();
-        CommIn.unPackRad();
-        CommIn.unPackInt8U();
-      }
-      return;
-    }
-    for (let i2 = 0;i2 < FramesBetweenSyncs; i2++) {
-      const controlKeys = CommIn.unPackInt8U();
-      if (controlKeys & Movement.Jump)
-        player.jumping = true;
-      else
-        player.jumping = false;
-      if (controlKeys & Movement.Scope)
-        player.scoping = true;
-      else
-        player.scoping = false;
-      const oldView = { ...player.view };
-      player.view.yaw = CommIn.unPackRadU();
-      player.view.pitch = CommIn.unPackRad();
-      if (player.view.yaw !== oldView.yaw || player.view.pitch !== oldView.pitch)
-        this.emit("playerRotate", player, oldView, player.view);
-      player.scale = CommIn.unPackInt8U();
-    }
-    const px = player.position;
-    const posChanged = px.x !== x || px.y !== y || px.z !== z;
-    const climbingChanged = player.climbing !== climbing;
-    const didChange = posChanged || climbingChanged;
-    const oldPosition = didChange ? { ...px } : null;
-    if (px.x !== x)
-      px.x = x;
-    if (px.z !== z)
-      px.z = z;
-    if (!player.jumping || Math.abs(px.y - y) > 0.5)
-      px.y = y;
-    if (climbingChanged)
-      player.climbing = climbing;
-    if (!didChange)
-      return;
-    this.emit("playerMove", player, oldPosition, px);
-    if (this.game.gameModeId !== GameMode.KOTC)
-      return;
-    const zone = this.game.activeZone;
-    const wasIn = !!player.inKotcZone;
-    if (!zone && wasIn) {
-      player.inKotcZone = false;
-      this.emit("playerLeaveZone", player);
-      return;
-    }
-    player.updateKotcZone(zone);
-    const nowIn = !!player.inKotcZone;
-    if (wasIn !== nowIn) {
-      player.inKotcZone = nowIn;
-      this.emit(nowIn ? "playerEnterZone" : "playerLeaveZone", player);
-    }
-  }
-  #processPausePacket() {
-    const id = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (player) {
-      player.playing = false;
-      if (player.streakRewards)
-        player.streakRewards = [];
-      this.emit("playerPause", player);
-      if (player.inKotcZone) {
-        player.inKotcZone = false;
-        this.emit("playerLeaveZone", player);
-      }
-    }
-  }
-  #processSwapWeaponPacket() {
-    const id = CommIn.unPackInt8U();
-    const newWeaponId = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (player) {
-      player.activeGun = newWeaponId;
-      this.emit("playerSwapWeapon", player, newWeaponId);
-    }
-  }
-  #processDeathPacket() {
-    const killedId = CommIn.unPackInt8U();
-    const killerId = CommIn.unPackInt8U();
-    CommIn.unPackInt8U();
-    CommIn.unPackInt8U();
-    const damageCauseInt = CommIn.unPackInt8U();
-    const killed = this.players[killedId];
-    const killer = this.players[killerId];
-    const oldKilled = killed ? { ...killed } : null;
-    if (killed) {
-      if (killed.id === this.me.id)
-        this.lastDeathTime = Date.now();
-      killed.playing = false;
-      killed.streak = 0;
-      killed.hp = 100;
-      killed.spawnShield = 0;
-      killed.stats.totalDeaths++;
-      killed.inKotcZone = false;
-      this.emit("playerLeaveZone", killed);
-    }
-    if (killer) {
-      killer.streak++;
-      killer.stats.totalKills++;
-      if (killer.streak > killer.stats.bestStreak)
-        killer.stats.bestStreak = killer.streak;
-    }
-    this.emit("playerDeath", killed, killer, oldKilled, damageCauseInt);
-  }
-  #processFirePacket() {
-    const id = CommIn.unPackInt8U();
-    const bullet = {
-      posX: CommIn.unPackFloat(),
-      posY: CommIn.unPackFloat(),
-      posZ: CommIn.unPackFloat(),
-      dirX: CommIn.unPackFloat(),
-      dirY: CommIn.unPackFloat(),
-      dirZ: CommIn.unPackFloat()
-    };
-    const player = this.players[id];
-    if (!player)
-      return;
-    const playerWeapon = player.weapons[player.activeGun];
-    if (playerWeapon && playerWeapon.ammo) {
-      playerWeapon.ammo.rounds--;
-      this.emit("playerFire", player, playerWeapon, bullet);
-    }
-  }
-  #processSpawnItemPacket() {
-    const id = CommIn.unPackInt16U();
-    const type = CommIn.unPackInt8U();
-    const x = CommIn.unPackFloat();
-    const y = CommIn.unPackFloat();
-    const z = CommIn.unPackFloat();
-    this.game.collectables[type].push({ id, x, y, z });
-    this.emit("spawnItem", type, { x, y, z }, id);
-  }
-  #processCollectPacket() {
-    const playerId = CommIn.unPackInt8U();
-    const type = CommIn.unPackInt8U();
-    const applyToWeaponIdx = CommIn.unPackInt8U();
-    const id = CommIn.unPackInt16U();
-    const player = this.players[playerId];
-    if (!player)
-      return;
-    this.game.collectables[type] = this.game.collectables[type].filter((c) => c.id !== id);
-    if (type === CollectType.Ammo) {
-      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("playerCollectAmmo", player, playerWeapon, id);
-      }
-    }
-    if (type === CollectType.Grenade) {
-      player.grenades++;
-      if (player.grenades > 3)
-        player.grenades = 3;
-      this.emit("playerCollectGrenade", player, id);
-    }
-  }
-  #processHitThemPacket() {
-    const id = CommIn.unPackInt8U();
-    const hp = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (!player)
-      return;
-    const oldHealth = player.hp;
-    player.hp = hp;
-    this.emit("playerDamage", player, oldHealth, player.hp);
-  }
-  #processHitMePacket() {
-    const hp = CommIn.unPackInt8U();
-    CommIn.unPackFloat();
-    CommIn.unPackFloat();
-    const oldHealth = this.me.hp;
-    this.me.hp = hp;
-    this.emit("playerDamage", this.me, oldHealth, this.me.hp);
-  }
-  #processSyncMePacket() {
-    const id = CommIn.unPackInt8U();
-    const player = this.players[id];
-    CommIn.unPackInt8U();
-    const serverStateIdx = CommIn.unPackInt8U();
-    const newX = CommIn.unPackFloat();
-    const newY = CommIn.unPackFloat();
-    const newZ = CommIn.unPackFloat();
-    this.me.climbing = !!CommIn.unPackInt8U();
-    CommIn.unPackInt8U();
-    CommIn.unPackInt8U();
-    if (!player)
-      return;
-    this.state.serverStateIdx = serverStateIdx;
-    const oldX = player.position.x;
-    const oldY = player.position.y;
-    const oldZ = player.position.z;
-    player.position.x = newX;
-    player.position.y = newY;
-    player.position.z = newZ;
-    if (oldX !== newX || oldY !== newY || oldZ !== newZ)
-      this.emit("playerMove", player, { x: oldX, y: oldY, z: oldZ }, { x: newX, y: newY, z: newZ });
-  }
-  #processEventModifierPacket() {
-    const out = new CommOut;
-    out.packInt8(CommCode.eventModifier);
-    out.send(this.game.socket);
-  }
-  #processRemovePlayerPacket() {
-    const id = CommIn.unPackInt8U();
-    const removedPlayer = { ...this.players[id] };
-    delete this.players[id];
-    this.emit("playerLeave", removedPlayer);
-  }
-  #processGameStatePacket() {
-    if (this.game.gameModeId === GameMode.Spatula) {
-      const oldGame = { ...this.game };
-      this.game.teamScore[1] = CommIn.unPackInt16U();
-      this.game.teamScore[2] = CommIn.unPackInt16U();
-      const spatulaCoords = {
-        x: CommIn.unPackFloat(),
-        y: CommIn.unPackFloat(),
-        z: CommIn.unPackFloat()
-      };
-      const controlledBy = CommIn.unPackInt8U();
-      const controlledByTeam = CommIn.unPackInt8U();
-      this.game.spatula = { coords: spatulaCoords, controlledBy, controlledByTeam };
-      this.emit("gameStateChange", oldGame, this.game);
-    } else if (this.game.gameModeId === GameMode.KOTC) {
-      const oldGame = { ...this.game };
-      this.game.stage = CommIn.unPackInt8U();
-      this.game.zoneNumber = CommIn.unPackInt8U();
-      this.game.capturing = CommIn.unPackInt8U();
-      this.game.captureProgress = CommIn.unPackInt16U();
-      this.game.numCapturing = CommIn.unPackInt8U();
-      this.game.teamScore[1] = CommIn.unPackInt8U();
-      this.game.teamScore[2] = CommIn.unPackInt8U();
-      this.game.capturePercent = this.game.captureProgress / 1000;
-      this.game.activeZone = this.game.map.zones ? this.game.map.zones[this.game.zoneNumber - 1] : null;
-      const oldPlayersOnZone = Object.values(this.players).filter((p) => p.inKotcZone && p.playing);
-      if (this.game.activeZone)
-        Object.values(this.players).forEach((player) => player.updateKotcZone(this.game.activeZone));
-      if (this.game.numCapturing <= 0)
-        Object.values(this.players).forEach((player) => {
-          player.inKotcZone = false;
-          this.emit("playerLeaveZone", player);
-        });
-      this.emit("gameStateChange", oldGame, this.game, oldPlayersOnZone);
-    } else if (this.game.gameModeId === GameMode.Team) {
-      this.game.teamScore[1] = CommIn.unPackInt16U();
-      this.game.teamScore[2] = CommIn.unPackInt16U();
-    }
-    if (this.game.gameModeId !== GameMode.Spatula)
-      delete this.game.spatula;
-    if (this.game.gameModeId !== GameMode.KOTC) {
-      delete this.game.stage;
-      delete this.game.zoneNumber;
-      delete this.game.capturing;
-      delete this.game.captureProgress;
-      delete this.game.numCapturing;
-      delete this.game.numCapturing;
-      delete this.game.activeZone;
-    }
-    if (this.game.gameModeId === GameMode.FFA)
-      delete this.game.teamScore;
-  }
-  #processBeginStreakPacket() {
-    const id = CommIn.unPackInt8U();
-    const ksType = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (!player)
-      return;
-    switch (ksType) {
-      case ShellStreak.HardBoiled:
-        if (id === this.me.id)
-          this.me.shieldHp = 100;
-        player.streakRewards.push(ShellStreak.HardBoiled);
-        break;
-      case ShellStreak.EggBreaker:
-        player.streakRewards.push(ShellStreak.EggBreaker);
-        break;
-      case ShellStreak.Restock: {
-        player.grenades = 3;
-        if (player.weapons[0] && player.weapons[0].ammo) {
-          player.weapons[0].ammo.rounds = player.weapons[0].ammo.capacity;
-          player.weapons[0].ammo.store = player.weapons[0].ammo.storeMax;
-        }
-        if (player.weapons[1] && player.weapons[1].ammo) {
-          player.weapons[1].ammo.rounds = player.weapons[1].ammo.capacity;
-          player.weapons[1].ammo.store = player.weapons[1].ammo.storeMax;
-        }
-        break;
-      }
-      case ShellStreak.OverHeal:
-        player.hp = Math.min(200, player.hp + 100);
-        player.streakRewards.push(ShellStreak.OverHeal);
-        break;
-      case ShellStreak.DoubleEggs:
-        player.streakRewards.push(ShellStreak.DoubleEggs);
-        break;
-      case ShellStreak.MiniEgg:
-        player.scale = 0.5;
-        player.streakRewards.push(ShellStreak.MiniEgg);
-        break;
-    }
-    this.emit("playerBeginStreak", player, ksType);
-  }
-  #processEndStreakPacket() {
-    const id = CommIn.unPackInt8U();
-    const ksType = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (!player)
-      return;
-    const streaks = [
-      ShellStreak.EggBreaker,
-      ShellStreak.OverHeal,
-      ShellStreak.DoubleEggs,
-      ShellStreak.MiniEgg
-    ];
-    if (streaks.includes(ksType) && player.streakRewards.includes(ksType))
-      player.streakRewards = player.streakRewards.filter((r) => r !== ksType);
-    if (ksType === ShellStreak.MiniEgg)
-      player.scale = 1;
-    this.emit("playerEndStreak", player, ksType);
-  }
-  #processHitShieldPacket() {
-    const shieldHealth = CommIn.unPackInt8U();
-    const playerHealth = CommIn.unPackInt8U();
-    const dx = CommIn.unPackFloat();
-    const dz = CommIn.unPackFloat();
-    if (!this.me)
-      return;
-    this.me.shieldHp = shieldHealth;
-    this.me.hp = playerHealth;
-    if (this.me.shieldHp <= 0) {
-      this.me.streakRewards = this.me.streakRewards.filter((r) => r !== ShellStreak.HardBoiled);
-      this.emit("selfShieldLost", this.me.hp, { dx, dz });
-    } else
-      this.emit("selfShieldHit", this.me.shieldHp, this.me.hp, { dx, dz });
-  }
-  #processGameOptionsPacket() {
-    const oldOptions = { ...this.game.options };
-    let gravity = CommIn.unPackInt8U();
-    let damage = CommIn.unPackInt8U();
-    let healthRegen = CommIn.unPackInt8U();
-    if (gravity < 1 || gravity > 4) {
-      gravity = 4;
-    }
-    if (damage < 0 || damage > 8) {
-      damage = 4;
-    }
-    if (healthRegen > 16) {
-      healthRegen = 4;
-    }
-    this.game.options.gravity = gravity / 4;
-    this.game.options.damage = damage / 4;
-    this.game.options.healthRegen = healthRegen / 4;
-    const rawFlags = CommIn.unPackInt8U();
-    Object.keys(CCGameOptionFlag).forEach((optionFlagName) => {
-      const value = rawFlags & CCGameOptionFlag[optionFlagName] ? 1 : 0;
-      this.game.options[optionFlagName] = value;
-    });
-    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);
-  }
-  #processGameActionPacket() {
-    const action = CommIn.unPackInt8U();
-    if (action === GameAction.Pause) {
-      this.emit("gameForcePause");
-      setTimeout(() => this.me.playing = false, 3000);
-    }
-    if (action === GameAction.Reset) {
-      Object.values(this.players).forEach((player) => player.streak = 0);
-      if (this.game.gameModeId !== GameMode.FFA)
-        this.game.teamScore = [0, 0, 0];
-      if (this.game.gameModeId === GameMode.Spatula) {
-        this.game.spatula.controlledBy = 0;
-        this.game.spatula.controlledByTeam = 0;
-        this.game.spatula.coords = { x: 0, y: 0, z: 0 };
-      }
-      if (this.game.gameModeId === GameMode.KOTC) {
-        this.game.stage = CoopState.Capturing;
-        this.game.zoneNumber = 0;
-        this.game.activeZone = null;
-        this.game.capturing = 0;
-        this.game.captureProgress = 0;
-        this.game.numCapturing = 0;
-        this.game.capturePercent = 0;
-      }
-      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);
-    setTimeout(() => {
-      const out = new CommOut;
-      out.packInt8(CommCode.ping);
-      out.send(this.game.socket);
-      this.lastPingTime = Date.now();
-    }, 1000);
-  }
-  #processSwitchTeamPacket() {
-    const id = CommIn.unPackInt8U();
-    const toTeam = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (!player)
-      return;
-    const oldTeam = player.team;
-    player.team = toTeam;
-    player.streak = 0;
-    this.emit("playerSwitchTeam", player, oldTeam, toTeam);
-  }
-  #processChangeCharacterPacket() {
-    const id = CommIn.unPackInt8U();
-    const weaponIndex = CommIn.unPackInt8U();
-    const primaryWeaponIdx = CommIn.unPackInt16U();
-    const secondaryWeaponIdx = CommIn.unPackInt16U();
-    const shellColor = CommIn.unPackInt8U();
-    const hatIdx = CommIn.unPackInt16U();
-    const stampIdx = CommIn.unPackInt16U();
-    const grenadeIdx = CommIn.unPackInt16U();
-    const meleeIdx = CommIn.unPackInt16U();
-    const stampPositionX = CommIn.unPackInt8();
-    const stampPositionY = CommIn.unPackInt8();
-    const findCosmetics = this.intents.includes(this.Intents.COSMETIC_DATA);
-    const primaryWeaponItem = findCosmetics ? findItemById(primaryWeaponIdx) : primaryWeaponIdx;
-    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) {
-      const oldCharacter = { ...player.character };
-      const oldWeaponIdx = player.selectedGun;
-      player.character.eggColor = shellColor;
-      player.character.primaryGun = primaryWeaponItem;
-      player.character.secondaryGun = secondaryWeaponItem;
-      player.character.stamp = stampItem;
-      player.character.hat = hatItem;
-      player.character.grenade = grenadeItem;
-      player.character.melee = meleeItem;
-      player.character.stampPos.x = stampPositionX;
-      player.character.stampPos.y = stampPositionY;
-      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);
-    }
-  }
-  #processUpdateBalancePacket() {
-    const newBalance = CommIn.unPackInt32U();
-    const oldBalance = this.account.eggBalance;
-    this.account.eggBalance = newBalance;
-    this.emit("balanceUpdate", oldBalance, newBalance);
-  }
-  #processRespawnDeniedPacket() {
-    this.me.playing = false;
-    this.emit("respawnDenied");
-  }
-  #processMeleePacket() {
-    const id = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (player)
-      this.emit("playerMelee", player);
-  }
-  #processReloadPacket() {
-    const id = CommIn.unPackInt8U();
-    const player = this.players[id];
-    if (!player)
-      return;
-    const playerActiveWeapon = player.weapons[player.activeGun];
-    if (playerActiveWeapon.ammo) {
-      const newRounds = Math.min(Math.min(playerActiveWeapon.ammo.capacity, playerActiveWeapon.ammo.reload) - playerActiveWeapon.ammo.rounds, playerActiveWeapon.ammo.store);
-      playerActiveWeapon.ammo.rounds += newRounds;
-      playerActiveWeapon.ammo.store -= newRounds;
-    }
-    this.emit("playerReload", player, playerActiveWeapon);
+  emit(event, ...args) {
+    const dispatch = DispatchIndex[event];
+    if (dispatch)
+      this.dispatch(new dispatch(...args), true);
+    else
+      throw new Error(`no event found for "${event}"`);
   }
   updateGameOptions() {
     const out = new CommOut;
@@ -1221,193 +847,78 @@ export class Bot {
     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);
-    });
+    this.game.options.weaponsDisabled.forEach((v) => out.packInt8(v ? 1 : 0));
     out.send(this.game.socket);
   }
-  #processGameRequestOptionsPacket() {
-    this.game.isPrivate = true;
-    this.updateGameOptions();
-  }
-  #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 === ItemType.Grenade)
-      this.emit("grenadeExplode", 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();
-  }
-  #processSocketReadyPacket() {
-    const out = new CommOut;
-    out.packInt8(this.intents.includes(this.Intents.OBSERVE_GAME) ? CommCode.observeGame : CommCode.joinGame);
-    out.packString(this.game.raw.uuid);
-    out.packInt8(+this.intents.includes(this.Intents.VIP_HIDE_BADGE));
-    out.packInt8(this.state.weaponIdx || this.account?.loadout?.classIdx || 0);
-    out.packString(this.state.name);
-    out.packInt32(this.account.session);
-    out.packString(this.account.sessionId);
-    out.packString(this.account.firebaseId);
-    out.send(this.game.socket);
-  }
-  async#processGameJoinedPacket() {
-    this.me.id = CommIn.unPackInt8U();
-    this.me.team = CommIn.unPackInt8U();
-    this.game.gameModeId = CommIn.unPackInt8U();
-    this.game.gameMode = GameModeById[this.game.gameModeId];
-    this.game.mapIdx = CommIn.unPackInt8U();
-    this.game.map = Maps[this.game.mapIdx];
-    this.game.playerLimit = CommIn.unPackInt8U();
-    this.game.isGameOwner = CommIn.unPackInt8U() === 1;
-    this.game.isPrivate = CommIn.unPackInt8U() === 1 || this.game.isGameOwner;
-    CommIn.unPackInt8U();
-    if (this.intents.includes(this.Intents.LOAD_MAP) || this.intents.includes(this.Intents.PATHFINDING)) {
-      this.game.map.raw = await fetchMap(this.game.map.filename, this.game.map.hash);
-      this.emit("mapLoad", this.game.map.raw);
-      if (this.game.gameModeId === GameMode.KOTC) {
-        const meshData = this.game.map.raw.data["DYNAMIC.capture-zone.none"];
-        if (meshData) {
-          this.game.map.zones = initKotcZones(meshData);
-          if (!this.game.activeZone)
-            this.game.activeZone = this.game.map.zones[this.game.zoneNumber - 1];
-        } else
-          delete this.game.map.zones;
-      }
-      if (this.intents.includes(this.Intents.PATHFINDING))
-        this.pathing.nodeList = new NodeList(this.game.map.raw);
-    }
-    this.state.inGame = true;
-    this.lastDeathTime = Date.now();
-    const out = new CommOut;
-    out.packInt8(CommCode.clientReady);
-    out.send(this.game.socket);
-    this.updateIntervalId = setInterval(() => this.update(), 100 / 3);
-    if (this.intents.includes(this.Intents.PING)) {
-      this.lastPingTime = Date.now();
-      const out2 = new CommOut;
-      out2.packInt8(CommCode.ping);
-      out2.send(this.game.socket);
-    }
-    if (this.intents.includes(this.Intents.NO_AFK_KICK))
-      this.afkKickInterval = setInterval(() => {
-        if (this.state.inGame && !this.me.playing && Date.now() - this.lastDeathTime >= 15000) {
-          const out3 = new CommOut;
-          out3.packInt8(CommCode.keepAlive);
-          out3.send(this.game.socket);
-        }
-      }, 15000);
-    this.emit("gameReady");
-  }
-  #processPlayerInfoPacket() {
-    const playerId = CommIn.unPackInt8U();
-    const playerDBId = CommIn.unPackString(128);
-    const playerIp = CommIn.unPackString(32);
-    const player = this.players[playerId];
-    if (!player)
-      return;
-    player.admin = {
-      ip: playerIp,
-      dbId: playerDBId
-    };
-    this.emit("playerInfo", player, playerIp, playerDBId);
-  }
   packetHandlers = {
-    [CommCode.syncThem]: () => this.#processSyncThemPacket(),
-    [CommCode.fire]: () => this.#processFirePacket(),
-    [CommCode.hitThem]: () => this.#processHitThemPacket(),
-    [CommCode.syncMe]: () => this.#processSyncMePacket(),
-    [CommCode.hitMe]: () => this.#processHitMePacket(),
-    [CommCode.swapWeapon]: () => this.#processSwapWeaponPacket(),
-    [CommCode.collectItem]: () => this.#processCollectPacket(),
-    [CommCode.respawn]: () => this.#processRespawnPacket(),
-    [CommCode.die]: () => this.#processDeathPacket(),
-    [CommCode.pause]: () => this.#processPausePacket(),
-    [CommCode.chat]: () => this.#processChatPacket(),
-    [CommCode.addPlayer]: () => this.#processAddPlayerPacket(),
-    [CommCode.removePlayer]: () => this.#processRemovePlayerPacket(),
-    [CommCode.eventModifier]: () => this.#processEventModifierPacket(),
-    [CommCode.metaGameState]: () => this.#processGameStatePacket(),
-    [CommCode.beginShellStreak]: () => this.#processBeginStreakPacket(),
-    [CommCode.endShellStreak]: () => this.#processEndStreakPacket(),
-    [CommCode.hitMeHardBoiled]: () => this.#processHitShieldPacket(),
-    [CommCode.gameOptions]: () => this.#processGameOptionsPacket(),
-    [CommCode.ping]: () => this.#processPingPacket(),
-    [CommCode.switchTeam]: () => this.#processSwitchTeamPacket(),
-    [CommCode.changeCharacter]: () => this.#processChangeCharacterPacket(),
-    [CommCode.reload]: () => this.#processReloadPacket(),
-    [CommCode.explode]: () => this.#processExplodePacket(),
-    [CommCode.throwGrenade]: () => this.#processThrowGrenadePacket(),
-    [CommCode.spawnItem]: () => this.#processSpawnItemPacket(),
-    [CommCode.melee]: () => this.#processMeleePacket(),
-    [CommCode.updateBalance]: () => this.#processUpdateBalancePacket(),
-    [CommCode.challengeCompleted]: () => this.#processChallengeCompletePacket(),
-    [CommCode.socketReady]: () => this.#processSocketReadyPacket(),
-    [CommCode.gameJoined]: () => this.#processGameJoinedPacket(),
-    [CommCode.gameAction]: () => this.#processGameActionPacket(),
-    [CommCode.requestGameOptions]: () => this.#processGameRequestOptionsPacket(),
-    [CommCode.respawnDenied]: () => this.#processRespawnDeniedPacket(),
-    [CommCode.playerInfo]: () => this.#processPlayerInfoPacket(),
+    [CommCode.syncThem]: processSyncThemPacket.bind(null, this),
+    [CommCode.fire]: processFirePacket.bind(null, this),
+    [CommCode.hitThem]: processHitThemPacket.bind(null, this),
+    [CommCode.syncMe]: processSyncMePacket.bind(null, this),
+    [CommCode.hitMe]: processHitMePacket.bind(null, this),
+    [CommCode.swapWeapon]: processSwapWeaponPacket.bind(null, this),
+    [CommCode.collectItem]: processCollectItemPacket.bind(null, this),
+    [CommCode.respawn]: processRespawnPacket.bind(null, this),
+    [CommCode.die]: processDiePacket.bind(null, this),
+    [CommCode.pause]: processPausePacket.bind(null, this),
+    [CommCode.chat]: processChatPacket.bind(null, this),
+    [CommCode.addPlayer]: processAddPlayerPacket.bind(null, this),
+    [CommCode.removePlayer]: processRemovePlayerPacket.bind(null, this),
+    [CommCode.eventModifier]: processEventModifierPacket.bind(null, this),
+    [CommCode.metaGameState]: processMetaGameStatePacket.bind(null, this),
+    [CommCode.beginShellStreak]: processBeginShellStreakPacket.bind(null, this),
+    [CommCode.endShellStreak]: processEndShellStreakPacket.bind(null, this),
+    [CommCode.hitMeHardBoiled]: processHitMeHardBoiledPacket.bind(null, this),
+    [CommCode.gameOptions]: processGameOptionsPacket.bind(null, this),
+    [CommCode.ping]: processPingPacket.bind(null, this),
+    [CommCode.switchTeam]: processSwitchTeamPacket.bind(null, this),
+    [CommCode.changeCharacter]: processChangeCharacterPacket.bind(null, this),
+    [CommCode.reload]: processReloadPacket.bind(null, this),
+    [CommCode.explode]: processExplodePacket.bind(null, this),
+    [CommCode.throwGrenade]: processThrowGrenadePacket.bind(null, this),
+    [CommCode.spawnItem]: processSpawnItemPacket.bind(null, this),
+    [CommCode.melee]: processMeleePacket.bind(null, this),
+    [CommCode.updateBalance]: processUpdateBalancePacket.bind(null, this),
+    [CommCode.challengeCompleted]: processChallengeCompletedPacket.bind(null, this),
+    [CommCode.gameAction]: processGameActionPacket.bind(null, this),
+    [CommCode.socketReady]: processSocketReadyPacket.bind(null, this),
+    [CommCode.gameJoined]: processGameJoinedPacket.bind(null, this),
+    [CommCode.playerInfo]: processPlayerInfoPacket.bind(null, this),
+    [CommCode.respawnDenied]: () => {
+      this.me.playing = false;
+      this.$emit("respawnDenied");
+    },
+    [CommCode.requestGameOptions]: () => {
+      this.game.isPrivate = true;
+      this.updateGameOptions();
+    },
     [CommCode.expireUpgrade]: () => {},
     [CommCode.clientReady]: () => {},
     [CommCode.musicInfo]: () => CommIn.unPackLongString()
   };
   processPacket(packet) {
+    if (this.hasQuit)
+      return;
     CommIn.init(packet);
-    if (this.intents.includes(this.Intents.PACKET_HOOK))
-      this.emit("packet", packet);
+    if (this.intents.includes(Intents.PACKET_HOOK))
+      this.$emit("packet", packet);
     let lastCommand = 0;
     let lastCode = 0;
-    let abort = false;
-    while (CommIn.isMoreDataAvailable() && !abort) {
+    while (CommIn.isMoreDataAvailable()) {
       const cmd = CommIn.unPackInt8U();
       const handler = this.packetHandlers[cmd];
       if (handler)
         handler();
       else {
-        console.error(`processPacket: I got but couldn't identify a: ${Object.keys(CommCode).find((k) => CommCode[k] === cmd)} ${cmd}`);
+        console.error(`processPacket: got but couldn't identify: ${Object.keys(CommCode).find((k) => CommCode[k] === cmd)} ${cmd}`);
         if (lastCommand)
-          console.error(`processPacket: It may be a result of the ${lastCommand} command (${lastCode}).`);
-        abort = true;
+          console.error(`processPacket: it may be a result of the ${lastCommand} command (${lastCode}).`);
         break;
       }
       lastCommand = Object.keys(CommCode).find((k) => CommCode[k] === cmd);
       lastCode = cmd;
-      if (this.intents.includes(this.Intents.LOG_PACKETS))
-        console.log(`[LOG_PACKETS] Packet ${lastCommand}: ${lastCode}`);
+      if (this.intents.includes(Intents.LOG_PACKETS))
+        console.log(`[LOG_PACKETS] packet ${lastCommand}: ${lastCode}`);
     }
   }
   async checkChiknWinner() {
@@ -1416,19 +927,19 @@ export class Bot {
       id: this.account.id,
       sessionId: this.account.sessionId
     });
-    if (typeof response === "string")
+    if (!response.ok)
       return response;
     this.account.cw.limit = response.limit;
     this.account.cw.atLimit = response.limit >= 4;
     this.account.cw.secondsUntilPlay = (this.account.cw.atLimit ? response.period : response.span) || 0;
     this.account.cw.canPlayAgain = Date.now() + this.account.cw.secondsUntilPlay * 1000;
-    return this.account.cw;
+    return { ok: true, cw: this.account.cw };
   }
   async playChiknWinner(doPrematureCooldownCheck = true) {
     if (this.account.cw.atLimit || this.account.cw.limit > ChiknWinnerDailyLimit)
-      return "hit_daily_limit";
+      return createError(ChicknWinnerError.HitDailyLimit);
     if (this.account.cw.canPlayAgain > Date.now() && doPrematureCooldownCheck)
-      return "on_cooldown";
+      return createError(ChicknWinnerError.OnCooldown);
     const response = await this.api.queryServices({
       cmd: "incentivizedVideoReward",
       firebaseId: this.account.firebaseId,
@@ -1436,62 +947,73 @@ export class Bot {
       sessionId: this.account.sessionId,
       token: null
     });
-    if (typeof response === "string")
+    if (!response.ok)
       return response;
     if (response.error) {
       if (response.error === "RATELIMITED" || response.error === "RATELMITED") {
         await this.checkChiknWinner();
-        return "on_cooldown";
+        return createError(ChicknWinnerError.OnCooldown);
       } else if (response.error === "SESSION_EXPIRED") {
-        this.emit("sessionExpired");
-        return "session_expired";
+        this.$emit("sessionExpired");
+        return createError(ChicknWinnerError.SessionExpired);
       }
-      console.error("Unknown Chikn Winner response, report this on Github:", response);
-      return "unknown_error";
+      this.errorLogger("unknown Chikn Winner response, report this on Github:", response);
+      return createError(ChicknWinnerError.InternalError);
     }
     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;
+      return { ok: true, ...response.reward };
     }
-    console.error("Unknown Chikn Winner response, report this on Github:", response);
-    return "unknown_error";
+    this.errorLogger("unknown Chikn Winner response, report this on Github:", response);
+    return createError(ChicknWinnerError.InternalError);
   }
   async resetChiknWinner() {
     if (this.account.eggBalance < 200)
-      return "not_enough_eggs";
+      return createError(ChicknWinnerError.NotEnoughResetEggs);
     if (!this.account.cw.atLimit)
-      return "not_at_limit";
+      return createError(ChicknWinnerError.NotAtDailyLimit);
     const response = await this.api.queryServices({
       cmd: "chwReset",
       sessionId: this.account.sessionId
     });
-    if (typeof response === "string")
+    if (!response.ok)
       return response;
     if (response.result !== "SUCCESS") {
-      console.error("Unknown Chikn Winner reset response, report this on Github:", response);
-      return "unknown_error";
+      this.errorLogger("unknown Chikn Winner reset response, report this on Github:", response);
+      return createError(ChicknWinnerError.InternalError);
     }
     this.account.eggBalance -= 200;
     await this.checkChiknWinner();
-    return this.account.cw;
+    return { ok: true, cw: this.account.cw };
   }
   canSee(target) {
-    if (!this.intents.includes(this.Intents.PATHFINDING))
-      return this.processError("You must have the PATHFINDING intent to use this method.");
+    if (!this.intents.includes(Intents.PATHFINDING))
+      throw new Error("canSee: you need enable the PATHFINDING intent");
     return this.pathing.nodeList.hasLineOfSight(this.me.position, target.position);
   }
+  getBestTarget() {
+    const options = Object.values(this.players).filter((player) => player?.playing).filter((player) => player.hp > 0).filter((player) => player.id !== this.me.id).filter((player) => this.me.team === 0 || player.team !== this.me.team);
+    const distancePlayers = options.map((player) => ({
+      player,
+      distance: (player.position.x - this.me.position.x) ** 2 + 5 * (player.position.y - this.me.position.y) ** 2 + (player.position.z - this.me.position.z) ** 2
+    })).sort((a, b) => a.distance - b.distance);
+    if (distancePlayers.length)
+      return distancePlayers[0].player;
+    else
+      return null;
+  }
   async refreshChallenges() {
     const result = await this.api.queryServices({
       cmd: "challengeGetDaily",
       sessionId: this.account.sessionId,
       playerId: this.account.id
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
     this.#importChallenges(result);
-    return this.account.challenges;
+    return { ok: true, challenges: this.account.challenges };
   }
   async rerollChallenge(challengeId) {
     const result = await this.api.queryServices({
@@ -1499,10 +1021,17 @@ export class Bot {
       sessionId: this.account.sessionId,
       slotId: challengeId
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
-    this.#importChallenges(result);
-    return this.account.challenges;
+    if (result["0"]) {
+      this.#importChallenges(Object.values(result));
+      return { ok: true, challenges: this.account.challenges };
+    }
+    const isInEnum = Object.values(ChallengeRerollError).includes(result.error);
+    if (isInEnum)
+      return { ok: false, error: result.error };
+    this.errorLogger("rerollChallenge: unknown error response", result);
+    return { ok: false, error: ChallengeRerollError.InternalError };
   }
   async claimChallenge(challengeId) {
     const result = await this.api.queryServices({
@@ -1510,15 +1039,19 @@ export class Bot {
       sessionId: this.account.sessionId,
       slotId: challengeId
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
-    this.#importChallenges(result.challenges);
-    if (result.reward > 0)
-      this.account.eggBalance += result.reward;
-    return {
-      eggReward: result.reward,
-      updatedChallenges: this.account.challenges
-    };
+    if (result.reward) {
+      this.#importChallenges(result.challenges);
+      if (result.reward > 0)
+        this.account.eggBalance += result.reward;
+      return { ok: true, eggReward: result.reward, updatedChallenges: this.account.challenges };
+    }
+    const isInEnum = Object.values(ChallengeClaimError).includes(result.error);
+    if (isInEnum)
+      return { ok: false, error: result.error };
+    this.errorLogger("claimChallenge: unknown error response", result);
+    return { ok: false, error: ChallengeClaimError.InternalError };
   }
   async refreshBalance() {
     const result = await this.api.queryServices({
@@ -1526,10 +1059,10 @@ export class Bot {
       firebaseId: this.account.firebaseId,
       sessionId: this.account.sessionId
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
     this.account.eggBalance = result.currentBalance;
-    return result.currentBalance;
+    return { ok: true, currentBalance: result.currentBalance };
   }
   async redeemCode(code) {
     const result = await this.api.queryServices({
@@ -1539,18 +1072,18 @@ export class Bot {
       id: this.account.id,
       code
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
     if (result.result === "SUCCESS") {
-      this.account.eggBalance = result.eggs_given;
+      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
-      };
+      return { ok: true, eggsGiven: result.eggs_given, itemIds: result.item_ids };
     }
-    return result;
+    const isInEnum = Object.values(RedeemCodeError).includes(result.result);
+    if (isInEnum)
+      return { ok: false, error: result.result };
+    this.errorLogger("redeemCode: unknown error response", result);
+    return { ok: false, error: RedeemCodeError.InternalError };
   }
   async claimURLReward(reward) {
     const result = await this.api.queryServices({
@@ -1559,13 +1092,18 @@ export class Bot {
       sessionId: this.account.sessionId,
       reward
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
     if (result.result === "SUCCESS") {
       this.account.eggBalance += result.eggsGiven;
       result.itemIds.forEach((id) => this.account.ownedItemIds.push(id));
+      return { ok: true, eggsGiven: result.eggsGiven, itemIds: result.itemIds };
     }
-    return result;
+    const isInEnum = Object.values(ClaimURLError).includes(result.result);
+    if (isInEnum)
+      return { ok: false, error: result.result };
+    this.errorLogger("claimURLReward: unknown error response", result);
+    return { ok: false, error: ClaimURLError.InternalError };
   }
   async claimSocialReward(rewardTag) {
     const result = await this.api.queryServices({
@@ -1574,13 +1112,18 @@ export class Bot {
       sessionId: this.account.sessionId,
       rewardTag
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
     if (result.result === "SUCCESS") {
       this.account.eggBalance += result.eggsGiven;
       result.itemIds.forEach((id) => this.account.ownedItemIds.push(id));
+      return { ok: true, eggsGiven: result.eggsGiven, itemIds: result.itemIds };
     }
-    return result;
+    const isInEnum = Object.values(ClaimSocialError).includes(result.result);
+    if (isInEnum)
+      return { ok: false, error: result.result };
+    this.errorLogger("claimSocialReward: unknown error response", result);
+    return { ok: false, error: ClaimSocialError.InternalError };
   }
   async buyItem(itemId) {
     const result = await this.api.queryServices({
@@ -1590,34 +1133,32 @@ export class Bot {
       itemId,
       save: true
     });
-    if (typeof result === "string")
+    if (!result.ok)
       return result;
     if (result.result === "SUCCESS") {
       this.account.eggBalance = result.currentBalance;
       this.account.ownedItemIds.push(result.itemId);
+      return { ok: true, itemId: result.itemId, currentBalance: result.currentBalance };
     }
-    return result;
-  }
-  processError(...params) {
-    const error = params.join(" ");
-    if (this.#hooks.error && this.#hooks.error.length)
-      this.emit("error", error);
-    else if (this.intents.includes(this.Intents.NO_EXIT_ON_ERROR))
-      console.error(error);
-    else
-      throw new Error(error);
+    const isInEnum = Object.values(BuyItemError).includes(result.result);
+    if (isInEnum)
+      return { ok: false, error: result.result };
+    this.errorLogger("buyItem: unknown error response", result);
+    return { ok: false, error: BuyItemError.InternalError };
   }
   leave(code = CloseCode.mainMenu) {
     if (this.hasQuit)
       return;
+    this.state.inGame = false;
     if (code > -1) {
       this.game?.socket?.close(code);
-      this.state.left = true;
-      this.emit("leave", code);
+      this.$emit("leave", code);
     }
-    clearInterval(this.updateIntervalId);
+    if (this.updateIntervalId)
+      clearInterval(this.updateIntervalId);
+    if (this.pingTimeoutId)
+      clearTimeout(this.pingTimeoutId);
     this.#dispatches = [];
-    this.state.inGame = false;
     this.state.chatLines = 0;
     this.state.reloading = false;
     this.state.swappingGun = false;
@@ -1632,10 +1173,8 @@ export class Bot {
     this.ping = 0;
     this.lastPingTime = -1;
     this.lastDeathTime = -1;
-    this.lastUpdateTick = 0;
     this.pathing = {
       nodeList: null,
-      followingPath: false,
       activePath: null,
       activeNode: null,
       activeNodeIdx: 0
@@ -1643,37 +1182,45 @@ export class Bot {
   }
   logout() {
     this.account = this.#initialAccount;
-    if (this.intents.includes(this.Intents.RENEW_SESSION))
+    if (this.intents.includes(Intents.RENEW_SESSION))
       clearInterval(this.renewSessionInterval);
   }
-  quit(noCleanup = false) {
+  quit(cleanupLevel = CleanupLevel.Partial) {
     if (this.hasQuit)
       return;
+    this.hasQuit = true;
     this.leave();
     if (this.matchmaker) {
-      this.matchmaker.close();
-      if (!noCleanup)
-        delete this.matchmaker;
+      try {
+        this.matchmaker.close();
+      } catch {}
+      if (cleanupLevel >= CleanupLevel.Partial)
+        this.matchmaker = null;
     }
-    if (!noCleanup) {
-      delete this.account;
-      delete this.api;
-      delete this.game;
-      delete this.me;
-      delete this.pathing;
-      delete this.players;
-      delete this.state;
+    if (this.intents.includes(Intents.NO_AFK_KICK))
+      clearInterval(this.afkKickInterval);
+    if (this.intents.includes(Intents.RENEW_SESSION))
+      clearInterval(this.renewSessionInterval);
+    if (this.pingTimeoutId)
+      clearTimeout(this.pingTimeoutId);
+    if (cleanupLevel >= CleanupLevel.Partial) {
+      this.api = null;
+      this.packetHandlers = null;
+      this.pathing = null;
       this.#initialAccount = {};
       this.#initialGame = {};
       this.#hooks = {};
       this.#globalHooks = [];
       this.#dispatches = [];
+      this.matchmakerListeners = [];
+      if (cleanupLevel >= CleanupLevel.Full) {
+        this.account = null;
+        this.game = null;
+        this.me = null;
+        this.players = null;
+        this.state = null;
+      }
     }
-    if (this.intents.includes(this.Intents.NO_AFK_KICK))
-      clearInterval(this.afkKickInterval);
-    if (this.intents.includes(this.Intents.RENEW_SESSION))
-      clearInterval(this.renewSessionInterval);
-    this.hasQuit = true;
   }
 }
 export default Bot;