yolkbot 1.4.8 → 1.5.1

package/dist/packets/respawn.js

@@ -0,0 +1,31 @@
+import CommIn from "../comm/CommIn.js";
+const processRespawnPacket = (bot) => {
+  const id = CommIn.unPackInt8U();
+  const seed = CommIn.unPackInt16U();
+  const x = CommIn.unPackFloat();
+  const y = CommIn.unPackFloat();
+  const z = CommIn.unPackFloat();
+  const primaryRounds = CommIn.unPackInt8U();
+  const primaryStore = CommIn.unPackInt8U();
+  const secondaryRounds = CommIn.unPackInt8U();
+  const secondaryStore = CommIn.unPackInt8U();
+  const grenades = CommIn.unPackInt8U();
+  const player = bot.players[id];
+  if (player) {
+    player.playing = true;
+    player.randomSeed = seed;
+    if (player.weapons[0] && player.weapons[0].ammo)
+      player.weapons[0].ammo.rounds = primaryRounds;
+    if (player.weapons[0] && player.weapons[0].ammo)
+      player.weapons[0].ammo.store = primaryStore;
+    if (player.weapons[1] && player.weapons[1].ammo)
+      player.weapons[1].ammo.rounds = secondaryRounds;
+    if (player.weapons[1] && player.weapons[1].ammo)
+      player.weapons[1].ammo.store = secondaryStore;
+    player.grenades = grenades;
+    player.position = { x, y, z };
+    player.spawnShield = 120;
+    bot.$emit("playerRespawn", player);
+  }
+};
+export default processRespawnPacket;

package/dist/packets/socketReady.js

@@ -0,0 +1,16 @@
+import CommOut from "../comm/CommOut.js";
+import CommCode from "../constants/CommCode.js";
+import { Intents } from "../enums.js";
+const processSocketReadyPacket = (bot) => {
+  const out = new CommOut;
+  out.packInt8(bot.intents.includes(Intents.OBSERVE_GAME) ? CommCode.observeGame : CommCode.joinGame);
+  out.packString(bot.game.raw.uuid);
+  out.packInt8(+bot.intents.includes(Intents.VIP_HIDE_BADGE));
+  out.packInt8(bot.state.weaponIdx || bot.account.loadout?.classIdx || 0);
+  out.packString(bot.state.name);
+  out.packInt32(bot.account.session);
+  out.packString(bot.account.sessionId);
+  out.packString(bot.account.firebaseId);
+  out.send(bot.game.socket);
+};
+export default processSocketReadyPacket;

package/dist/packets/spawnItem.js

@@ -0,0 +1,11 @@
+import CommIn from "../comm/CommIn.js";
+const processSpawnItemPacket = (bot) => {
+  const id = CommIn.unPackInt16U();
+  const type = CommIn.unPackInt8U();
+  const x = CommIn.unPackFloat();
+  const y = CommIn.unPackFloat();
+  const z = CommIn.unPackFloat();
+  bot.game.collectibles[type].push({ id, x, y, z });
+  bot.$emit("spawnItem", type, { x, y, z }, id);
+};
+export default processSpawnItemPacket;

package/dist/packets/swapWeapon.js

@@ -0,0 +1,11 @@
+import CommIn from "../comm/CommIn.js";
+const processSwapWeaponPacket = (bot) => {
+  const id = CommIn.unPackInt8U();
+  const newWeaponId = CommIn.unPackInt8U();
+  const player = bot.players[id];
+  if (player) {
+    player.activeGun = newWeaponId;
+    bot.$emit("playerSwapWeapon", player, newWeaponId);
+  }
+};
+export default processSwapWeaponPacket;

package/dist/packets/switchTeam.js

@@ -0,0 +1,13 @@
+import CommIn from "../comm/CommIn.js";
+const processSwitchTeamPacket = (bot) => {
+  const id = CommIn.unPackInt8U();
+  const toTeam = CommIn.unPackInt8U();
+  const player = bot.players[id];
+  if (!player)
+    return;
+  const oldTeam = player.team;
+  player.team = toTeam;
+  player.streak = 0;
+  bot.$emit("playerSwitchTeam", player, oldTeam, toTeam);
+};
+export default processSwitchTeamPacket;

package/dist/packets/syncMe.js

@@ -0,0 +1,25 @@
+import CommIn from "../comm/CommIn.js";
+const processSyncMePacket = (bot) => {
+  const id = CommIn.unPackInt8U();
+  const player = bot.players[id];
+  CommIn.unPackInt8U();
+  const serverStateIdx = CommIn.unPackInt8U();
+  const newX = CommIn.unPackFloat();
+  const newY = CommIn.unPackFloat();
+  const newZ = CommIn.unPackFloat();
+  bot.me.climbing = !!CommIn.unPackInt8U();
+  CommIn.unPackInt8U();
+  CommIn.unPackInt8U();
+  if (!player)
+    return;
+  bot.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)
+    bot.$emit("playerMove", player, { x: oldX, y: oldY, z: oldZ }, { x: newX, y: newY, z: newZ });
+};
+export default processSyncMePacket;

package/dist/packets/syncThem.js

@@ -0,0 +1,63 @@
+import CommIn from "../comm/CommIn.js";
+import { FramesBetweenSyncs, GameMode, Movement } from "../constants/index.js";
+import { ZoneLeaveReason } from "../enums.js";
+const processSyncThemPacket = (bot) => {
+  const id = CommIn.unPackInt8U();
+  const x = CommIn.unPackFloat();
+  const y = CommIn.unPackFloat();
+  const z = CommIn.unPackFloat();
+  const climbing = CommIn.unPackInt8U();
+  const player = bot.players[id];
+  if (!player || player.id === bot.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();
+    player.jumping = !!(controlKeys & Movement.Jump);
+    player.scoping = !!(controlKeys & Movement.Scope);
+    const oldView = structuredClone(player.view);
+    player.view.yaw = CommIn.unPackRadU();
+    player.view.pitch = CommIn.unPackRad();
+    if (player.view.yaw !== oldView.yaw || player.view.pitch !== oldView.pitch)
+      bot.$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 ? structuredClone(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;
+  bot.$emit("playerMove", player, oldPosition, px);
+  if (bot.game.gameModeId !== GameMode.KOTC)
+    return;
+  const zone = bot.game.kotc.activeZone;
+  const wasIn = !!player.inKotcZone;
+  if (!zone && wasIn) {
+    player.inKotcZone = false;
+    bot.$emit("playerLeaveZone", player, ZoneLeaveReason.RoundEnded);
+    return;
+  }
+  player.updateKotcZone(zone);
+  const nowIn = !!player.inKotcZone;
+  if (wasIn !== nowIn) {
+    player.inKotcZone = nowIn;
+    bot.$emit(nowIn ? "playerEnterZone" : "playerLeaveZone", player, nowIn ? null : ZoneLeaveReason.WalkedOut);
+  }
+};
+export default processSyncThemPacket;

package/dist/packets/throwGrenade.js

@@ -0,0 +1,17 @@
+import CommIn from "../comm/CommIn.js";
+const processThrowGrenadePacket = (bot) => {
+  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 = bot.players[id];
+  if (player) {
+    if (player.grenades > 0)
+      player.grenades--;
+    bot.$emit("playerThrowGrenade", player, { x, y, z }, { x: dx, y: dy, z: dz });
+  }
+};
+export default processThrowGrenadePacket;

package/dist/packets/updateBalance.js

@@ -0,0 +1,8 @@
+import CommIn from "../comm/CommIn.js";
+const processUpdateBalancePacket = (bot) => {
+  const newBalance = CommIn.unPackInt32U();
+  const oldBalance = bot.account.eggBalance;
+  bot.account.eggBalance = newBalance;
+  bot.$emit("balanceUpdate", oldBalance, newBalance);
+};
+export default processUpdateBalancePacket;

package/dist/pathing/astar.js

@@ -1,10 +1,13 @@
-import { BinaryHeap } from "./binaryheap.js";
 export default class AStar {
   constructor(list) {
     this.list = list;
   }
   heuristic(pos1, pos2) {
-    return Math.abs(pos1.x - pos2.x) + Math.abs(pos1.y - pos2.y) + Math.abs(pos1.z - pos2.z);
+    const dx = Math.abs(pos1.x - pos2.x);
+    const dy = Math.abs(pos1.y - pos2.y);
+    const dz = Math.abs(pos1.z - pos2.z);
+    const dxz = Math.max(dx, dz);
+    return dy + dxz;
   }
   reversePath(node) {
     const path = [];
@@ -17,36 +20,46 @@ export default class AStar {
   }
   path(start, end) {
     this.list.clean();
-    const heap = new BinaryHeap((node) => node.f);
-    const closedSet = [];
+    const openSet = [start];
+    const closedSet = new Set;
     start.h = this.heuristic(start, end);
     start.g = 0;
-    start.f = start.g + start.h;
-    heap.push(start);
-    while (heap.size() !== 0) {
-      const current = heap.pop();
-      if (current === end) {
-        const val = this.reversePath(current);
-        return val;
+    start.f = start.h;
+    start.visited = true;
+    let current;
+    while (openSet.length > 0) {
+      let lowestIdx = 0;
+      let lowestF = openSet[0].f;
+      let lowestG = openSet[0].g;
+      for (let i = 1;i < openSet.length; i++) {
+        const node = openSet[i];
+        if (node.f < lowestF || node.f === lowestF && node.g > lowestG) {
+          lowestF = node.f;
+          lowestG = node.g;
+          lowestIdx = i;
+        }
       }
-      closedSet.push(current);
+      current = openSet[lowestIdx];
+      if (current === end)
+        return this.reversePath(current);
+      openSet[lowestIdx] = openSet[openSet.length - 1];
+      openSet.pop();
+      closedSet.add(current);
       const neighbors = current.links;
       for (let i = 0;i < neighbors.length; i++) {
         const neighbor = neighbors[i];
-        if (closedSet.includes(neighbor))
+        if (closedSet.has(neighbor))
           continue;
         const tentativeGScore = current.g + 1;
-        const visited = neighbor.visited;
-        if (!visited || tentativeGScore < neighbor.g) {
+        if (!neighbor.visited || tentativeGScore < neighbor.g) {
+          const isNew = !neighbor.visited;
           neighbor.visited = true;
           neighbor.parent = current;
           neighbor.g = tentativeGScore;
-          neighbor.h = this.heuristic(neighbor.position, end.position);
+          neighbor.h = this.heuristic(neighbor, end);
           neighbor.f = neighbor.g + neighbor.h;
-          if (visited)
-            heap.rescoreElement(neighbor);
-          else
-            heap.push(neighbor);
+          if (isNew)
+            openSet.push(neighbor);
         }
       }
     }

package/dist/pathing/mapnode.d.ts

@@ -14,6 +14,7 @@ declare class MapNode {
     parent: MapNode | null;
     closed: any | null;
     links: MapNode[];
+    flatCenter: Position;
     ry?: number;
 
     constructor(meshType: string, data: { x: number; y: number; z: number; ry?: number });
@@ -25,7 +26,6 @@ declare class MapNode {
     isStair(): boolean;
     isAir(): boolean;
     canLink(node: MapNode, list: NodeList): boolean;
-    flatCenter(): Position;
     flatRadialDistance(position: Position): number;
 }
 
@@ -36,6 +36,8 @@ declare class NodeList {
     constructor(raw: { data: Record<string, Array<{ x: number; y: number; z: number; ry?: number }>>, width: number, height: number, depth: number });
 
     at(x: number, y: number, z: number): MapNode | undefined;
+    atObject(position: Position): MapNode | undefined;
+
     clean(): void;
     hasLineOfSight(bot: Position, target: Position): boolean;
 }

package/dist/pathing/mapnode.js

@@ -1,10 +1,17 @@
+const FORWARD_RY_WEDGE_MAPPING = Object.freeze({
+  0: { x: 0, z: -1 },
+  1: { x: -1, z: 0 },
+  2: { x: 0, z: 1 },
+  3: { x: 1, z: 0 }
+});
+const positionKey = (x, y, z) => (x & 255) << 16 | (y & 255) << 8 | z & 255;
+
 class MapNode {
   constructor(meshType, data) {
     this.x = data.x;
     this.y = data.y;
     this.z = data.z;
-    this.positionStr = `${this.x},${this.y},${this.z}`;
-    this.position = { x: this.x, y: this.y, z: this.z };
+    this.positionKey = positionKey(this.x, this.y, this.z);
     this.meshType = meshType.split(".").pop();
     this.f = 0;
     this.g = 0;
@@ -13,12 +20,13 @@ class MapNode {
     this.parent = null;
     this.closed = null;
     this.links = [];
-    if (this.isStair()) {
-      if (data.ry)
-        this.ry = data.ry;
-      else
-        this.ry = 0;
-    }
+    this.flatCenter = {
+      x: this.x + 0.5,
+      y: this.y,
+      z: this.z + 0.5
+    };
+    if (this.meshType === "wedge")
+      this.ry = data.ry ?? 0;
   }
   isFull() {
     return this.meshType === "full";
@@ -38,6 +46,9 @@ class MapNode {
   isAir() {
     return this.meshType === "none";
   }
+  isJumpPad() {
+    return this.meshType === "jump-pad";
+  }
   canLink(node, list) {
     const dx0 = this.x - node.x;
     const dz0 = this.z - node.z;
@@ -45,103 +56,197 @@ class MapNode {
     const dx = Math.abs(dx0);
     const dy = Math.abs(dy0);
     const dz = Math.abs(dz0);
-    if (dx + dy + dz === 0 || dx + dz > 1 || this.isFull() || node.isFull())
+    if (dx + dy + dz === 0 || dx + dz > 1 && !(dx === 2 && dz === 1 || dx === 1 && dz === 2 || dx === 2 && dz === 2) || this.isFull() || node.isFull())
       return false;
     const belowMe = list.at(this.x, this.y - 1, this.z);
     const belowOther = list.at(node.x, node.y - 1, node.z);
     if (!belowMe || !belowOther)
       return false;
-    const FORWARD_RY_WEDGE_MAPPING = {
-      0: { x: 0, z: -1 },
-      1: { x: -1, z: 0 },
-      2: { x: 0, z: 1 },
-      3: { x: 1, z: 0 }
-    };
-    switch (this.meshType) {
-      case "none":
+    if (dy === 0 && belowMe.isFull() && belowOther.isFull()) {
+      if (dx === 2 && dz === 0 || dx === 0 && dz === 2) {
+        const midX = (this.x + node.x) / 2;
+        const midZ = (this.z + node.z) / 2;
+        const midNode = list.at(midX, this.y, midZ);
+        const midBelow = list.at(midX, this.y - 1, midZ);
+        const midAbove = list.at(midX, this.y + 1, midZ);
+        if (midBelow && midBelow.isAir()) {
+          if (midNode && midNode.isAir() && midAbove && midAbove.isAir()) {
+            const startHead = list.at(this.x, this.y + 1, this.z);
+            const endHead = list.at(node.x, node.y + 1, node.z);
+            if (startHead && startHead.isAir() && endHead && endHead.isAir()) {
+              return true;
+            }
+          }
+        }
+      } else if (dx === 2 && dz === 1 || dx === 1 && dz === 2) {
+        const xDir = dx0 > 0 ? -1 : 1;
+        const zDir = dz0 > 0 ? -1 : 1;
+        const checks = dx === 2 ? [
+          [this.x + xDir, this.y, this.z],
+          [this.x + xDir, this.y, this.z + zDir]
+        ] : [
+          [this.x, this.y, this.z + zDir],
+          [this.x + xDir, this.y, this.z + zDir]
+        ];
+        let allClear = true;
+        for (const [x, y, z] of checks) {
+          const block = list.at(x, y, z);
+          const blockBelow = list.at(x, y - 1, z);
+          const blockAbove = list.at(x, y + 1, z);
+          if (!block || !block.isAir() || !blockBelow || !blockBelow.isAir() || !blockAbove || !blockAbove.isAir()) {
+            allClear = false;
+            break;
+          }
+        }
+        if (allClear) {
+          const startHead = list.at(this.x, this.y + 1, this.z);
+          const endHead = list.at(node.x, node.y + 1, node.z);
+          if (startHead && startHead.isAir() && endHead && endHead.isAir())
+            return true;
+        }
+      } else if (dx === 2 && dz === 2) {
+        const xDir = dx0 > 0 ? -1 : 1;
+        const zDir = dz0 > 0 ? -1 : 1;
+        const checks = [
+          [this.x + xDir, this.y, this.z + zDir],
+          [this.x + 2 * xDir, this.y, this.z + zDir],
+          [this.x + 2 * xDir, this.y, this.z + 2 * zDir]
+        ];
+        let allClear = true;
+        for (const [x, y, z] of checks) {
+          const block = list.at(x, y, z);
+          const blockBelow = list.at(x, y - 1, z);
+          const blockAbove = list.at(x, y + 1, z);
+          if (!block || !block.isAir() || !blockBelow || !blockBelow.isAir() || !blockAbove || !blockAbove.isAir()) {
+            allClear = false;
+            break;
+          }
+        }
+        if (allClear) {
+          const startHead = list.at(this.x, this.y + 1, this.z);
+          const endHead = list.at(node.x, node.y + 1, node.z);
+          if (startHead && startHead.isAir() && endHead && endHead.isAir())
+            return true;
+        }
+      }
+    }
+    const meSupported = belowMe.isFull() || this.isStair();
+    const otherSupported = belowOther.isFull() || belowOther.isStair() || node.isStair();
+    if (dy <= 2 && meSupported && otherSupported) {
+      if (this.meshType === "none") {
         if (dy0 === 1 && node.canWalkThrough())
           return true;
-        if (belowMe.canWalkOn() || belowMe.isLadder()) {
-          if (node.meshType === "none" || node.meshType === "ladder" && dy === 0 || node.meshType === "wedge" && dy0 === 0 && dx0 === -FORWARD_RY_WEDGE_MAPPING[node.ry].x && dz0 === -FORWARD_RY_WEDGE_MAPPING[node.ry].z) {
+        if (belowMe.canWalkOn() || belowMe.isLadder() || belowMe.isStair()) {
+          if (node.meshType === "none" || node.meshType === "ladder" && dy === 0 || node.meshType === "wedge" && dy0 === 0 && dx0 === -FORWARD_RY_WEDGE_MAPPING[node.ry].x && dz0 === -FORWARD_RY_WEDGE_MAPPING[node.ry].z)
             return true;
-          }
         }
         return false;
-      case "ladder":
+      } else if (this.meshType === "ladder") {
         if (dy === 1 && node.canWalkThrough())
           return true;
         if (dy === 0 && belowMe.canWalkOn())
           return true;
-        if (node.meshType === "ladder" && (dy === 1 || belowMe.canWalkOn() && belowOther.canWalkOn()))
-          return true;
-        return false;
-      case "wedge":
-        if (this.x + FORWARD_RY_WEDGE_MAPPING[this.ry].x === node.x && this.z + FORWARD_RY_WEDGE_MAPPING[this.ry].z === node.z && this.y + 1 === node.y)
+        return node.meshType === "ladder" && (dy === 1 || belowMe.canWalkOn() && belowOther.canWalkOn());
+      } else if (this.meshType === "wedge") {
+        const forward = FORWARD_RY_WEDGE_MAPPING[this.ry];
+        const backward = { x: -forward.x, z: -forward.z };
+        if (this.x + forward.x === node.x && this.z + forward.z === node.z) {
+          if (this.y + 1 === node.y && node.canWalkThrough())
+            return true;
+          if (this.y === node.y && node.meshType === "wedge")
+            return true;
+          if (this.y + 1 === node.y && node.meshType === "wedge")
+            return true;
+        }
+        if (this.x + backward.x === node.x && this.z + backward.z === node.z) {
+          if ((this.y === node.y || this.y - 1 === node.y) && node.canWalkThrough())
+            return true;
+          if (this.y - 1 === node.y && (node.meshType === "wedge" || node.meshType === "none" && belowOther.isFull()))
+            return true;
+        }
+        if (node.canWalkThrough() && (belowOther.isFull() || belowOther.isStair()))
           return true;
-        if (this.x - FORWARD_RY_WEDGE_MAPPING[this.ry].x === node.x && this.z - FORWARD_RY_WEDGE_MAPPING[this.ry].z === node.z && (this.y === node.y || this.y - 1 === node.y))
+        if (node.isStair())
           return true;
         return false;
-      default:
-        return false;
+      }
     }
-  }
-  flatCenter() {
-    return {
-      x: this.x + 0.5,
-      y: this.y + 0,
-      z: this.z + 0.5
-    };
+    return false;
   }
   flatRadialDistance(position) {
-    const pos = this.flatCenter();
-    return Math.hypot(pos.x - position.x, pos.z - position.z);
+    return Math.hypot(this.flatCenter.x - position.x, this.flatCenter.z - position.z);
   }
 }
+const NEIGHBOR_OFFSETS = [
+  [1, 0, 0],
+  [-1, 0, 0],
+  [0, 1, 0],
+  [0, -1, 0],
+  [0, 0, 1],
+  [0, 0, -1],
+  [1, 0, 1],
+  [1, 0, -1],
+  [-1, 0, 1],
+  [-1, 0, -1],
+  [1, 1, 0],
+  [-1, 1, 0],
+  [0, 1, 1],
+  [0, 1, -1],
+  [1, -1, 0],
+  [-1, -1, 0],
+  [0, -1, 1],
+  [0, -1, -1],
+  [2, 0, 0],
+  [-2, 0, 0],
+  [0, 0, 2],
+  [0, 0, -2],
+  [2, 0, 1],
+  [2, 0, -1],
+  [-2, 0, 1],
+  [-2, 0, -1],
+  [1, 0, 2],
+  [1, 0, -2],
+  [-1, 0, 2],
+  [-1, 0, -2],
+  [2, 0, 2],
+  [2, 0, -2],
+  [-2, 0, 2],
+  [-2, 0, -2]
+];
 
 class NodeList {
   list = [];
+  nodeMap = null;
   constructor(raw) {
-    const addedPositions = {};
-    for (const meshName of Object.keys(raw.data))
+    const addedPositions = new Set;
+    for (const meshName of Object.keys(raw.data)) {
       for (const nodeData of raw.data[meshName]) {
-        addedPositions[nodeData.x << 16 | nodeData.y << 8 | nodeData.z] = true;
+        addedPositions.add(positionKey(nodeData.x, nodeData.y, nodeData.z));
         this.list.push(new MapNode(meshName, nodeData));
       }
+    }
     for (let x = 0;x < raw.width; x++)
       for (let y = 0;y < raw.height; y++)
         for (let z = 0;z < raw.depth; z++)
-          if (!addedPositions[x << 16 | y << 8 | z])
+          if (!addedPositions.has(positionKey(x, y, z)))
             this.list.push(new MapNode("SPECIAL.air.none", { x, y, z }));
-    const nodeMap = new Map;
+    this.nodeMap = new Map;
     for (const node of this.list)
-      nodeMap.set(node.positionStr, node);
+      this.nodeMap.set(node.positionKey, node);
     for (const node of this.list) {
-      const neighbors = [
-        { x: node.x + 1, y: node.y, z: node.z },
-        { x: node.x - 1, y: node.y, z: node.z },
-        { x: node.x, y: node.y + 1, z: node.z },
-        { x: node.x, y: node.y - 1, z: node.z },
-        { x: node.x, y: node.y, z: node.z + 1 },
-        { x: node.x, y: node.y, z: node.z - 1 }
-      ];
-      for (const neighborPos of neighbors) {
-        const neighborKey = `${neighborPos.x},${neighborPos.y},${neighborPos.z}`;
-        const neighborNode = nodeMap.get(neighborKey);
+      for (const [dx, dy, dz] of NEIGHBOR_OFFSETS) {
+        const neighborKey = positionKey(node.x + dx, node.y + dy, node.z + dz);
+        const neighborNode = this.nodeMap.get(neighborKey);
         if (neighborNode && node.canLink(neighborNode, this))
           node.links.push(neighborNode);
       }
     }
   }
   at(x, y, z) {
-    if (!this.nodeMap) {
-      this.nodeMap = new Map;
-      for (const node of this.list) {
-        const key = `${node.x},${node.y},${node.z}`;
-        this.nodeMap.set(key, node);
-      }
-    }
-    const key = `${x},${y},${z}`;
-    return this.nodeMap.get(key);
+    return this.nodeMap?.get(positionKey(x, y, z));
+  }
+  atObject({ x, y, z }) {
+    return this.nodeMap?.get(positionKey(Math.floor(x), Math.floor(y), Math.floor(z)));
   }
   clean() {
     for (const node of this.list) {
@@ -166,7 +271,7 @@ class NodeList {
     let z = bot.z;
     for (let i = 0;i <= steps; i++) {
       const node = this.at(Math.round(x), Math.round(y), Math.round(z));
-      if (node && node.isFull())
+      if (node?.isFull())
         return false;
       x += xStep;
       y += yStep;

package/dist/socket.d.ts

@@ -1,17 +1,32 @@
 type Data = string | Buffer | ArrayBuffer | Buffer[];
 
+interface yolkwsParams {
+    proxy?: string;
+    errorLogger?: (...args: any[]) => void;
+}
+
 declare class yolkws {
-    constructor(url: string, proxy: string);
+    connected: boolean;
+    autoReconnect: boolean;
+
+    url: string;
+    proxy: string | undefined;
+
+    binaryType: string;
+
+    connectionTimeout: number;
+
+    constructor(url: string, params?: yolkwsParams);
 
-    tryConnect($tries?: number): Promise<void>;
+    tryConnect($tries?: number): Promise<boolean>;
 
-    onmessage: (data: Data) => void;
     onopen: () => void;
-    onclose: (code: number, reason: string) => void;
-    onerror: (err: Error) => void;
+    onmessage: (event: MessageEvent) => void;
+    onclose: (event: CloseEvent) => void;
+    onerror: (event: Event) => void;
 
     send(data: Data): void;
-    close(code?: number, reason?: string): void;
+    close(data?: number): void;
 }
 
 export default yolkws;