yolkbot 1.4.5 → 1.4.7

package/dist/pathing/astar.js

@@ -1 +1,55 @@
-import{BinaryHeap as l}from"./binaryheap.js";export default class AStar{constructor(e){this.list=e}heuristic(e,t){return Math.abs(e.x-t.x)+Math.abs(e.y-t.y)+Math.abs(e.z-t.z)}reversePath(e){const t=[];while(e.parent){t.push(e);e=e.parent}t.reverse();return t}path(e,t){this.list.clean();const n=new l((s)=>s.f),r=[];e.h=this.heuristic(e,t);e.g=0;e.f=e.g+e.h;n.push(e);while(n.size()!==0){const s=n.pop();if(s===t)return this.reversePath(s);r.push(s);const c=s.links;for(let h=0;h<c.length;h++){const i=c[h];if(r.includes(i))continue;const a=s.g+1,o=i.visited;if(!o||a<i.g){i.visited=!0;i.parent=s;i.g=a;i.h=this.heuristic(i.position,t.position);i.f=i.g+i.h;if(o)n.rescoreElement(i);else n.push(i)}}}return null}}
+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);
+  }
+  reversePath(node) {
+    const path = [];
+    while (node.parent) {
+      path.push(node);
+      node = node.parent;
+    }
+    path.reverse();
+    return path;
+  }
+  path(start, end) {
+    this.list.clean();
+    const heap = new BinaryHeap((node) => node.f);
+    const closedSet = [];
+    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;
+      }
+      closedSet.push(current);
+      const neighbors = current.links;
+      for (let i = 0;i < neighbors.length; i++) {
+        const neighbor = neighbors[i];
+        if (closedSet.includes(neighbor))
+          continue;
+        const tentativeGScore = current.g + 1;
+        const visited = neighbor.visited;
+        if (!visited || tentativeGScore < neighbor.g) {
+          neighbor.visited = true;
+          neighbor.parent = current;
+          neighbor.g = tentativeGScore;
+          neighbor.h = this.heuristic(neighbor.position, end.position);
+          neighbor.f = neighbor.g + neighbor.h;
+          if (visited)
+            heap.rescoreElement(neighbor);
+          else
+            heap.push(neighbor);
+        }
+      }
+    }
+    return null;
+  }
+}

package/dist/pathing/binaryheap.js

@@ -1 +1,79 @@
-class BinaryHeap{constructor(b){this.content=[];this.scoreFunction=b}push(b){this.content.push(b);this.bubbleUp(this.content.length-1)}rescoreElement(b){this.sinkDown(this.content.indexOf(b))}pop(){const b=this.content[0],j=this.content.pop();if(this.content.length>0){this.content[0]=j;this.sinkDown(0)}return b}remove(b){const j=this.content.length;for(let f=0;f<j;f++){if(this.content[f]!==b)continue;const k=this.content.pop();if(f===j-1)break;this.content[f]=k;this.bubbleUp(f);this.sinkDown(f);break}}size(){return this.content.length}bubbleUp(b){const j=this.content[b],f=this.scoreFunction(j);while(b>0){const k=Math.floor((b+1)/2)-1,q=this.content[k];if(f>=this.scoreFunction(q))break;this.content[k]=j;this.content[b]=q;b=k}}includes(b){return this.content.includes(b)}sinkDown(b){const j=this.content.length,f=this.content[b],k=this.scoreFunction(f);while(!0){const q=(b+1)*2,x=q-1;let v=null,z;if(x<j){const A=this.content[x];z=this.scoreFunction(A);if(z<k)v=x}if(q<j){const A=this.content[q];if(this.scoreFunction(A)<(v===null?k:z))v=q}if(v===null)break;this.content[b]=this.content[v];this.content[v]=f;b=v}}}export default BinaryHeap;export{BinaryHeap};
+class BinaryHeap {
+  constructor(scoreFunction) {
+    this.content = [];
+    this.scoreFunction = scoreFunction;
+  }
+  push(element) {
+    this.content.push(element);
+    this.bubbleUp(this.content.length - 1);
+  }
+  rescoreElement(node) {
+    this.sinkDown(this.content.indexOf(node));
+  }
+  pop() {
+    const result = this.content[0];
+    const end = this.content.pop();
+    if (this.content.length > 0) {
+      this.content[0] = end;
+      this.sinkDown(0);
+    }
+    return result;
+  }
+  remove(node) {
+    const length = this.content.length;
+    for (let i = 0;i < length; i++) {
+      if (this.content[i] !== node)
+        continue;
+      const end = this.content.pop();
+      if (i === length - 1)
+        break;
+      this.content[i] = end;
+      this.bubbleUp(i);
+      this.sinkDown(i);
+      break;
+    }
+  }
+  size() {
+    return this.content.length;
+  }
+  bubbleUp(n) {
+    const element = this.content[n], score = this.scoreFunction(element);
+    while (n > 0) {
+      const parentN = Math.floor((n + 1) / 2) - 1, parent = this.content[parentN];
+      if (score >= this.scoreFunction(parent))
+        break;
+      this.content[parentN] = element;
+      this.content[n] = parent;
+      n = parentN;
+    }
+  }
+  includes(n) {
+    return this.content.includes(n);
+  }
+  sinkDown(n) {
+    const length = this.content.length, element = this.content[n], elemScore = this.scoreFunction(element);
+    while (true) {
+      const child2N = (n + 1) * 2, child1N = child2N - 1;
+      let swap = null;
+      let child1Score;
+      if (child1N < length) {
+        const child1 = this.content[child1N];
+        child1Score = this.scoreFunction(child1);
+        if (child1Score < elemScore)
+          swap = child1N;
+      }
+      if (child2N < length) {
+        const child2 = this.content[child2N], child2Score = this.scoreFunction(child2);
+        if (child2Score < (swap === null ? elemScore : child1Score))
+          swap = child2N;
+      }
+      if (swap === null)
+        break;
+      this.content[n] = this.content[swap];
+      this.content[swap] = element;
+      n = swap;
+    }
+  }
+}
+export default BinaryHeap;
+export { BinaryHeap };

package/dist/pathing/mapnode.js

@@ -1 +1,179 @@
-class MapNode{constructor(t,i){this.x=i.x;this.y=i.y;this.z=i.z;this.positionStr=`${this.x},${this.y},${this.z}`;this.position={x:this.x,y:this.y,z:this.z};this.meshType=t.split(".").pop();this.f=0;this.g=0;this.h=0;this.visited=null;this.parent=null;this.closed=null;this.links=[];if(this.isStair())if(i.ry)this.ry=i.ry;else this.ry=0}isFull(){return this.meshType==="full"}canWalkThrough(){return this.meshType==="none"||this.meshType==="ladder"}canWalkOn(){return this.meshType==="full"}isLadder(){return this.meshType==="ladder"}isStair(){return this.meshType==="wedge"}isAir(){return this.meshType==="none"}canLink(t,i){const r=this.x-t.x,s=this.z-t.z,e=this.y-t.y,h=Math.abs(r),n=Math.abs(e),a=Math.abs(s);if(h+n+a===0||h+a>1||this.isFull()||t.isFull())return!1;const y=i.at(this.x,this.y-1,this.z),o=i.at(t.x,t.y-1,t.z);if(!y||!o)return!1;const l={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(e===1&&t.canWalkThrough())return!0;if(y.canWalkOn()||y.isLadder()){if(t.meshType==="none"||t.meshType==="ladder"&&n===0||t.meshType==="wedge"&&e===0&&r===-l[t.ry].x&&s===-l[t.ry].z)return!0}return!1;case"ladder":if(n===1&&t.canWalkThrough())return!0;if(n===0&&y.canWalkOn())return!0;if(t.meshType==="ladder"&&(n===1||y.canWalkOn()&&o.canWalkOn()))return!0;return!1;case"wedge":if(this.x+l[this.ry].x===t.x&&this.z+l[this.ry].z===t.z&&this.y+1===t.y)return!0;if(this.x-l[this.ry].x===t.x&&this.z-l[this.ry].z===t.z&&(this.y===t.y||this.y-1===t.y))return!0;return!1;default:return!1}}flatCenter(){return{x:this.x+0.5,y:this.y+0,z:this.z+0.5}}flatRadialDistance(t){const i=this.flatCenter();return Math.hypot(i.x-t.x,i.z-t.z)}}class NodeList{list=[];constructor(t){const i={};for(const s of Object.keys(t.data))for(const e of t.data[s]){i[e.x<<16|e.y<<8|e.z]=!0;this.list.push(new MapNode(s,e))}for(let s=0;s<t.width;s++)for(let e=0;e<t.height;e++)for(let h=0;h<t.depth;h++)if(!i[s<<16|e<<8|h])this.list.push(new MapNode("SPECIAL.air.none",{x:s,y:e,z:h}));const r=new Map;for(const s of this.list)r.set(s.positionStr,s);for(const s of this.list){const e=[{x:s.x+1,y:s.y,z:s.z},{x:s.x-1,y:s.y,z:s.z},{x:s.x,y:s.y+1,z:s.z},{x:s.x,y:s.y-1,z:s.z},{x:s.x,y:s.y,z:s.z+1},{x:s.x,y:s.y,z:s.z-1}];for(const h of e){const n=`${h.x},${h.y},${h.z}`,a=r.get(n);if(a&&s.canLink(a,this))s.links.push(a)}}}at(t,i,r){if(!this.nodeMap){this.nodeMap=new Map;for(const e of this.list){const h=`${e.x},${e.y},${e.z}`;this.nodeMap.set(h,e)}}const s=`${t},${i},${r}`;return this.nodeMap.get(s)}clean(){for(const t of this.list){t.f=0;t.g=0;t.h=0;t.visited=null;t.parent=null;t.closed=null}}hasLineOfSight(t,i){const r=i.x-t.x,s=i.y-t.y,e=i.z-t.z,h=Math.max(Math.abs(r),Math.abs(s),Math.abs(e)),n=r/h,a=s/h,y=e/h;let{x:o,y:l,z:u}=t;for(let c=0;c<=h;c++){const f=this.at(Math.round(o),Math.round(l),Math.round(u));if(f&&f.isFull())return!1;o+=n;l+=a;u+=y}return!0}}export default MapNode;export{MapNode,NodeList};
+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.meshType = meshType.split(".").pop();
+    this.f = 0;
+    this.g = 0;
+    this.h = 0;
+    this.visited = null;
+    this.parent = null;
+    this.closed = null;
+    this.links = [];
+    if (this.isStair()) {
+      if (data.ry)
+        this.ry = data.ry;
+      else
+        this.ry = 0;
+    }
+  }
+  isFull() {
+    return this.meshType === "full";
+  }
+  canWalkThrough() {
+    return this.meshType === "none" || this.meshType === "ladder";
+  }
+  canWalkOn() {
+    return this.meshType === "full";
+  }
+  isLadder() {
+    return this.meshType === "ladder";
+  }
+  isStair() {
+    return this.meshType === "wedge";
+  }
+  isAir() {
+    return this.meshType === "none";
+  }
+  canLink(node, list) {
+    const dx0 = this.x - node.x;
+    const dz0 = this.z - node.z;
+    const dy0 = this.y - node.y;
+    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())
+      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 (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) {
+            return true;
+          }
+        }
+        return false;
+      case "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 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))
+          return true;
+        return false;
+      default:
+        return false;
+    }
+  }
+  flatCenter() {
+    return {
+      x: this.x + 0.5,
+      y: this.y + 0,
+      z: this.z + 0.5
+    };
+  }
+  flatRadialDistance(position) {
+    const pos = this.flatCenter();
+    return Math.hypot(pos.x - position.x, pos.z - position.z);
+  }
+}
+
+class NodeList {
+  list = [];
+  constructor(raw) {
+    const addedPositions = {};
+    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;
+        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])
+            this.list.push(new MapNode("SPECIAL.air.none", { x, y, z }));
+    const nodeMap = new Map;
+    for (const node of this.list)
+      nodeMap.set(node.positionStr, 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);
+        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);
+  }
+  clean() {
+    for (const node of this.list) {
+      node.f = 0;
+      node.g = 0;
+      node.h = 0;
+      node.visited = null;
+      node.parent = null;
+      node.closed = null;
+    }
+  }
+  hasLineOfSight(bot, target) {
+    const dx = target.x - bot.x;
+    const dy = target.y - bot.y;
+    const dz = target.z - bot.z;
+    const steps = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
+    const xStep = dx / steps;
+    const yStep = dy / steps;
+    const zStep = dz / steps;
+    let x = bot.x;
+    let y = bot.y;
+    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())
+        return false;
+      x += xStep;
+      y += yStep;
+      z += zStep;
+    }
+    return true;
+  }
+}
+export default MapNode;
+export { MapNode, NodeList };

package/dist/socket.js

@@ -1 +1,97 @@
-import s from"./env/globals.js";import{UserAgent as l}from"./constants/index.js";class i{url="";proxy="";binaryType="";maxRetries=5;connectionTimeout=5000;constructor(e,o){if(s.isBrowser&&o)throw Error("You cannot pass a proxy to a WebSocket in a browser.");this.url=e;this.proxy=o}async tryConnect(e=1){const o=new URL(this.url),r=async()=>{if(e===5)return!1;return await this.tryConnect(e+1)};try{this.socket=s.isBrowser?new s.WebSocket(this.url):new s.WebSocket(this.url,{proxy:this.proxy||null,headers:{"accept-encoding":"gzip, deflate, br, zstd","accept-language":"en-US,en;q=0.9","cache-control":"no-cache",connection:"Upgrade",origin:o.origin.replace("ws","http"),pragma:"no-cache","sec-websocket-extensions":"permessage-deflate; client_max_window_bits","user-agent":l}});if(this.binaryType)this.socket.binaryType=this.binaryType}catch(t){console.error(`Failed to connect on try ${e}, trying again...`,t);return await r()}if(this.onBeforeConnect)this.onBeforeConnect();return new Promise((t)=>{const n=setTimeout(async()=>{this.socket.close();t(await r())},this.connectionTimeout),c=async(a)=>{clearTimeout(n);console.error("WebSocket error",a);t(await r())};this.socket.addEventListener("open",async()=>{clearTimeout(n);this.socket.removeEventListener("error",c);t(!0)});this.socket.addEventListener("error",c)})}get onmessage(){return this.socket?.onmessage}set onmessage(e){if(this.socket)this.socket.onmessage=e;else console.error("set onmessage before socket existed")}get onclose(){return this.socket?.onclose}set onclose(e){if(this.socket)this.socket.onclose=e;else console.error("set onclose before socket existed")}get onerror(){return this.socket?.onerror}set onerror(e){if(this.socket)this.socket.onerror=e;else console.error("set onclose before socket existed")}send(e){return this.socket?.send(e)}close(e){return this.socket?.close(e)}}export default i;
+import globals from "./env/globals.js";
+import { UserAgent } from "./constants/index.js";
+
+class yolkws {
+  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.");
+    this.url = url;
+    this.proxy = proxy;
+  }
+  async tryConnect(tries = 1) {
+    const url = new URL(this.url);
+    const retryOrQuit = async () => {
+      if (tries === 5)
+        return false;
+      return await this.tryConnect(tries + 1);
+    };
+    try {
+      this.socket = globals.isBrowser ? new globals.WebSocket(this.url) : new globals.WebSocket(this.url, {
+        proxy: this.proxy || null,
+        headers: {
+          "accept-encoding": "gzip, deflate, br, zstd",
+          "accept-language": "en-US,en;q=0.9",
+          "cache-control": "no-cache",
+          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);
+      return await retryOrQuit();
+    }
+    if (this.onBeforeConnect)
+      this.onBeforeConnect();
+    return new Promise((resolve) => {
+      const timeout = setTimeout(async () => {
+        this.socket.close();
+        resolve(await retryOrQuit());
+      }, this.connectionTimeout);
+      const errorListener = async (e) => {
+        clearTimeout(timeout);
+        console.error("WebSocket error", e);
+        resolve(await retryOrQuit());
+      };
+      this.socket.addEventListener("open", async () => {
+        clearTimeout(timeout);
+        this.socket.removeEventListener("error", errorListener);
+        resolve(true);
+      });
+      this.socket.addEventListener("error", errorListener);
+    });
+  }
+  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);
+  }
+}
+export default yolkws;

package/dist/util.js

@@ -1 +1,68 @@
-import u from"./env/globals.js";export const fetchMap=async(c,a)=>{if(!u.isIsolated&&typeof process<"u"){const{existsSync:i,mkdirSync:f,readFileSync:p,writeFileSync:o}=process.getBuiltinModule("node:fs"),{join:e}=process.getBuiltinModule("node:path"),{homedir:s}=process.getBuiltinModule("node:os"),t=e(s(),".yolkbot");if(!i(t))f(t);const l=e(t,"maps");if(!i(l))f(l);const r=e(l,`${c}-${a}.json`);if(i(r))return JSON.parse(p(r,"utf-8"));const z=await(await fetch(`https://esm.sh/gh/yolkorg/maps/maps/${c}.json?${a}`)).json();o(r,JSON.stringify(z,null,4),{flag:"w+"});return z}return await(await fetch(`https://esm.sh/gh/yolkorg/maps/maps/${c}.json?${a}`)).json()},initKotcZones=(c)=>{let a=0;const n={},i=[];for(const o of c){if(!n[o.x])n[o.x]={};if(!n[o.x][o.y])n[o.x][o.y]={};n[o.x][o.y][o.z]={zone:null}}const f=[{x:-1,z:0},{x:1,z:0},{x:0,z:-1},{x:0,z:1}],p=(o,e,s)=>n[o]&&n[o][e]&&n[o][e][s]?n[o][e][s]:null;for(const o of c)if(!n[o.x][o.y][o.z].zone){o.zone=++a;n[o.x][o.y][o.z].zone=o.zone;const e=[o];let s;do{s=0;for(const t of c)if(!n[t.x][t.y][t.z].zone)for(const l of f){const r=p(t.x+l.x,t.y,t.z+l.z);if(r&&r.zone===o.zone){s++;t.zone=o.zone;n[t.x][t.y][t.z].zone=o.zone;e.push(t);break}}}while(s>0);i.push(e)}return i};
+import globals from "./env/globals.js";
+export const fetchMap = async (name, hash) => {
+  if (!globals.isIsolated && typeof process !== "undefined") {
+    const { existsSync, mkdirSync, readFileSync, writeFileSync } = process.getBuiltinModule("node:fs");
+    const { join } = process.getBuiltinModule("node:path");
+    const { homedir } = process.getBuiltinModule("node:os");
+    const yolkbotCache = join(homedir(), ".yolkbot");
+    if (!existsSync(yolkbotCache))
+      mkdirSync(yolkbotCache);
+    const mapCache = join(yolkbotCache, "maps");
+    if (!existsSync(mapCache))
+      mkdirSync(mapCache);
+    const mapFile = join(mapCache, `${name}-${hash}.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();
+    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();
+  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 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);
+    }
+  }
+  return zones;
+};