yolkbot 1.4.7 → 1.5.0

package/dist/socket.js

@@ -1,17 +1,27 @@
 import globals from "./env/globals.js";
 import { UserAgent } from "./constants/index.js";
 
-class yolkws {
+export class yolkws {
+  connected = false;
+  autoReconnect = false;
   url = "";
   proxy = "";
   binaryType = "";
-  maxRetries = 5;
   connectionTimeout = 5000;
-  constructor(url, proxy) {
-    if (globals.isBrowser && proxy)
-      throw new Error("You cannot pass a proxy to a WebSocket in a browser.");
+  errorLogger = (...args) => console.error(...args);
+  onopen = () => {};
+  onmessage = () => {};
+  onclose = () => {};
+  onerror = () => {};
+  constructor(url, params = {}) {
+    if (typeof params !== "object")
+      params = {};
+    if (typeof process === "undefined" && params.proxy)
+      throw new Error("You cannot pass a proxy to a WebSocket in this environment.");
     this.url = url;
-    this.proxy = proxy;
+    this.proxy = params.proxy;
+    if (typeof params.errorLogger === "function")
+      this.errorLogger = params.errorLogger;
   }
   async tryConnect(tries = 1) {
     const url = new URL(this.url);
@@ -21,7 +31,7 @@ class yolkws {
       return await this.tryConnect(tries + 1);
     };
     try {
-      this.socket = globals.isBrowser ? new globals.WebSocket(this.url) : new globals.WebSocket(this.url, {
+      this.socket = typeof process === "undefined" ? new globals.WebSocket(this.url) : new globals.WebSocket(this.url, {
         proxy: this.proxy || null,
         headers: {
           "accept-encoding": "gzip, deflate, br, zstd",
@@ -30,14 +40,13 @@ class yolkws {
           connection: "Upgrade",
           origin: url.origin.replace("ws", "http"),
           pragma: "no-cache",
-          "sec-websocket-extensions": "permessage-deflate; client_max_window_bits",
           "user-agent": UserAgent
         }
       });
       if (this.binaryType)
         this.socket.binaryType = this.binaryType;
     } catch (e) {
-      console.error(`Failed to connect on try ${tries}, trying again...`, e);
+      this.errorLogger(`Failed to connect on try ${tries}, trying again...`, e);
       return await retryOrQuit();
     }
     if (this.onBeforeConnect)
@@ -49,49 +58,50 @@ class yolkws {
       }, this.connectionTimeout);
       const errorListener = async (e) => {
         clearTimeout(timeout);
-        console.error("WebSocket error", e);
+        this.errorLogger("WebSocket error", e);
         resolve(await retryOrQuit());
       };
       this.socket.addEventListener("open", async () => {
         clearTimeout(timeout);
+        this.connected = true;
+        this.onopen();
         this.socket.removeEventListener("error", errorListener);
+        this.socket.addEventListener("message", (messageEvent) => this.onmessage(messageEvent));
+        this.socket.addEventListener("close", (closeEvent) => !this.autoReconnect && this.onclose(closeEvent));
+        this.socket.addEventListener("error", (event) => this.onerror(event));
         resolve(true);
       });
       this.socket.addEventListener("error", errorListener);
+      this.socket.addEventListener("close", () => {
+        if (this.connected) {
+          this.connected = false;
+          if (this.autoReconnect)
+            setTimeout(async () => {
+              const didConnect = await this.tryConnect();
+              if (!didConnect) {
+                if (this.onclose)
+                  this.onclose();
+                this.errorLogger("tryConnect: failed to reconnect to", this.url, "after 5 attempts.");
+                this.errorLogger("tryConnect: please check your internet connection & ensure your IP isn't blocked.");
+              }
+            }, 250);
+        }
+      });
     });
   }
-  get onmessage() {
-    return this.socket?.onmessage;
-  }
-  set onmessage(handler) {
-    if (this.socket)
-      this.socket.onmessage = handler;
-    else
-      console.error("set onmessage before socket existed");
-  }
-  get onclose() {
-    return this.socket?.onclose;
-  }
-  set onclose(handler) {
-    if (this.socket)
-      this.socket.onclose = handler;
-    else
-      console.error("set onclose before socket existed");
-  }
-  get onerror() {
-    return this.socket?.onerror;
-  }
-  set onerror(handler) {
-    if (this.socket)
-      this.socket.onerror = handler;
-    else
-      console.error("set onclose before socket existed");
-  }
   send(data) {
     return this.socket?.send(data);
   }
   close(data) {
-    return this.socket?.close(data);
+    if (!this.socket)
+      return;
+    this.autoReconnect = false;
+    if (this.socket.terminate) {
+      try {
+        this.socket.terminate();
+      } catch {}
+    } else
+      this.socket.close(data);
   }
 }
 export default yolkws;

package/dist/util.d.ts

@@ -2,5 +2,8 @@ import { Zone } from './bot';
 import { Position } from './bot/GamePlayer';
 import { MapJSON } from './constants/maps';
 
+export declare function createGun<T extends { ammo: { capacity: number; store: number } }>(baseGun: T): T;
+export declare function createError<T = string>(message: T): { ok: false; error: T };
 export declare function fetchMap(name: string, hash: string): Promise<MapJSON>;
-export declare function initKotcZones(meshData: Array<Position>): Array<Array<Zone>>;
+export declare function initKotcZones(meshData: Array<Position>): Array<Array<Zone>>;
+export declare function isDoubleEggWeeknd(): boolean;

package/dist/util.js

@@ -1,6 +1,26 @@
-import globals from "./env/globals.js";
+export const createGun = (baseGun) => {
+  const gun = structuredClone(baseGun);
+  gun.ammo.rounds = gun.ammo.capacity;
+  gun.ammo.storeMax = gun.ammo.store;
+  return gun;
+};
+export const createError = (errorEnum) => ({ ok: false, error: errorEnum });
+const attemptFetch = async (url, options = {}, retries = 3, backoff = 300) => {
+  try {
+    const response = await fetch(url, options);
+    if (!response.ok)
+      throw new Error(`failed to fetch map; status: ${response.status}`);
+    return response;
+  } catch (error) {
+    if (retries > 0) {
+      await new Promise((res) => setTimeout(res, backoff));
+      return attemptFetch(url, options, retries - 1, backoff * 2);
+    } else
+      throw error;
+  }
+};
 export const fetchMap = async (name, hash) => {
-  if (!globals.isIsolated && typeof process !== "undefined") {
+  if (typeof process !== "undefined") {
     const { existsSync, mkdirSync, readFileSync, writeFileSync } = process.getBuiltinModule("node:fs");
     const { join } = process.getBuiltinModule("node:path");
     const { homedir } = process.getBuiltinModule("node:os");
@@ -10,59 +30,99 @@ export const fetchMap = async (name, hash) => {
     const mapCache = join(yolkbotCache, "maps");
     if (!existsSync(mapCache))
       mkdirSync(mapCache);
-    const mapFile = join(mapCache, `${name}-${hash}.json`);
+    const safeName = String(name).replace(/[^a-z0-9_-]/gi, "_");
+    const safeHash = String(hash).replace(/[^a-z0-9_-]/gi, "_");
+    const mapFile = join(mapCache, `${safeName}-${safeHash}.json`);
     if (existsSync(mapFile))
       return JSON.parse(readFileSync(mapFile, "utf-8"));
-    const data = await (await fetch(`https://x.yolkbot.xyz/data/maps/full/${name}.json?${hash}`)).json();
+    const data = await (await attemptFetch(`https://x.yolkbot.xyz/data/maps/full/${name}.json?${hash}`)).json();
     writeFileSync(mapFile, JSON.stringify(data, null, 4), { flag: "w+" });
     return data;
   }
-  const data = await (await fetch(`https://esm.sh/gh/yolkorg/maps/maps/${name}.json?${hash}`)).json();
+  const data = await (await attemptFetch(`https://x.yolkbot.xyz/data/maps/full/${name}.json?${hash}`)).json();
   return data;
 };
 export const initKotcZones = (meshData) => {
-  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 len = meshData.length;
+  if (!len)
+    return [];
+  let minX = 1 / 0, minY = 1 / 0, minZ = 1 / 0;
+  let maxX = -1 / 0, maxY = -1 / 0, maxZ = -1 / 0;
+  for (let i = 0;i < len; i++) {
+    const { x, y, z } = meshData[i];
+    if (x < minX)
+      minX = x;
+    if (x > maxX)
+      maxX = x;
+    if (y < minY)
+      minY = y;
+    if (y > maxY)
+      maxY = y;
+    if (z < minZ)
+      minZ = z;
+    if (z > maxZ)
+      maxZ = z;
   }
-  const offsets = [
-    { x: -1, z: 0 },
-    { x: 1, z: 0 },
-    { x: 0, z: -1 },
-    { x: 0, z: 1 }
-  ];
-  const getMapCellAt = (x, y, z) => 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);
+  const sizeX = maxX - minX + 1 | 0;
+  const sizeY = maxY - minY + 1 | 0;
+  const sizeZ = maxZ - minZ + 1 | 0;
+  const strideY = sizeX;
+  const strideZ = sizeX * sizeY;
+  const cellIndex = new Int32Array(sizeX * sizeY * sizeZ).fill(-1);
+  const zoneIds = new Uint16Array(len);
+  const queue = new Uint32Array(len);
+  for (let i = 0;i < len; i++) {
+    const { x, y, z } = meshData[i];
+    cellIndex[(x - minX | 0) + (y - minY | 0) * strideY + (z - minZ | 0) * strideZ] = i;
+  }
+  const zones = [];
+  let zoneId = 0;
+  for (let i = 0;i < len; i++) {
+    if (zoneIds[i])
+      continue;
+    const zone = ++zoneId;
+    const activeZone = [];
+    let head = 0, tail = 0;
+    queue[tail++] = i;
+    zoneIds[i] = zone;
+    while (head < tail) {
+      const idx = queue[head++];
+      const cell = meshData[idx];
+      cell.zone = zone;
+      activeZone[activeZone.length] = cell;
+      const { x, y, z } = cell;
+      const flatIdx = (x - minX | 0) + (y - minY | 0) * strideY + (z - minZ | 0) * strideZ;
+      let nIdx;
+      if (x > minX && (nIdx = cellIndex[flatIdx - 1]) !== -1 && !zoneIds[nIdx]) {
+        zoneIds[nIdx] = zone;
+        queue[tail++] = nIdx;
+      }
+      if (x < maxX && (nIdx = cellIndex[flatIdx + 1]) !== -1 && !zoneIds[nIdx]) {
+        zoneIds[nIdx] = zone;
+        queue[tail++] = nIdx;
+      }
+      if (y > minY && (nIdx = cellIndex[flatIdx - strideY]) !== -1 && !zoneIds[nIdx]) {
+        zoneIds[nIdx] = zone;
+        queue[tail++] = nIdx;
+      }
+      if (y < maxY && (nIdx = cellIndex[flatIdx + strideY]) !== -1 && !zoneIds[nIdx]) {
+        zoneIds[nIdx] = zone;
+        queue[tail++] = nIdx;
+      }
+      if (z > minZ && (nIdx = cellIndex[flatIdx - strideZ]) !== -1 && !zoneIds[nIdx]) {
+        zoneIds[nIdx] = zone;
+        queue[tail++] = nIdx;
+      }
+      if (z < maxZ && (nIdx = cellIndex[flatIdx + strideZ]) !== -1 && !zoneIds[nIdx]) {
+        zoneIds[nIdx] = zone;
+        queue[tail++] = nIdx;
+      }
     }
+    zones[zones.length] = activeZone;
   }
   return zones;
 };
+export const isDoubleEggWeeknd = () => {
+  const day = new Date().getUTCDay();
+  return day >= 5 && new Date().getUTCHours() >= 20 || day === 6 || day === 0;
+};

package/dist/wasm/bytes.d.ts

@@ -1 +1 @@
-export declare const wasmBytes: string;
+export declare const wasmBytes: Uint8Array;