@nxg-org/mineflayer-util-plugin 1.3.2 → 1.3.7

package/lib/calcs/aabb.d.ts

@@ -19,6 +19,7 @@ export declare class AABB {
         0: Vec3;
         1: Vec3;
     };
+    toVertices(): Vec3[];
     floor(): void;
     extend(dx: number, dy: number, dz: number): this;
     contract(x: number, y: number, z: number): this;
@@ -28,13 +29,19 @@ export declare class AABB {
     computeOffsetY(other: AABB, offsetY: number): number;
     computeOffsetZ(other: AABB, offsetZ: number): number;
     intersects(other: AABB): boolean;
-    xzIntersectsRay(origin: Vec3, direction: Vec3): {
+    xzIntersectsRay(org: Vec3, dir: Vec3): {
         x: number;
         z: number;
     } | null;
-    intersectsRay(origin: Vec3, direction: Vec3): Vec3 | null;
+    intersectsRay(org: Vec3, dir: Vec3): Vec3 | null;
+    xzIntersectsSegment(org: Vec3, dest: Vec3): {
+        x: number;
+        z: number;
+    } | null;
+    intersectsSegment(org: Vec3, dest: Vec3): Vec3 | null;
     distanceFromRay(origin: Vec3, direction: Vec3, xz?: boolean): number;
     equals(other: AABB): boolean;
+    xzDistanceTo(pos: Vec3, heightOffset?: number): number;
     distanceTo(pos: Vec3, heightOffset?: number): number;
 }
 export default AABB;

package/lib/calcs/aabb.js

@@ -34,6 +34,18 @@ class AABB {
     toVecs() {
         return { 0: new vec3_1.Vec3(this.minX, this.minY, this.minZ), 1: new vec3_1.Vec3(this.maxX, this.maxY, this.maxZ) };
     }
+    toVertices() {
+        return [
+            new vec3_1.Vec3(this.minX, this.minY, this.minZ),
+            new vec3_1.Vec3(this.minX, this.minY, this.maxZ),
+            new vec3_1.Vec3(this.minX, this.maxY, this.minZ),
+            new vec3_1.Vec3(this.minX, this.maxY, this.maxZ),
+            new vec3_1.Vec3(this.maxX, this.minY, this.minZ),
+            new vec3_1.Vec3(this.maxX, this.minY, this.maxZ),
+            new vec3_1.Vec3(this.maxX, this.maxY, this.minZ),
+            new vec3_1.Vec3(this.maxX, this.maxY, this.maxZ),
+        ];
+    }
     floor() {
         this.minX = Math.floor(this.minX);
         this.minY = Math.floor(this.minY);
@@ -125,17 +137,29 @@ class AABB {
             this.minZ < other.maxZ &&
             this.maxZ > other.minZ);
     }
-    xzIntersectsRay(origin, direction) {
-        const d = this.distanceFromRay(origin, direction, true);
-        return d === Infinity ? null : { x: origin.x + direction.x * d, z: origin.z + direction.z * d };
+    xzIntersectsRay(org, dir) {
+        const d = this.distanceFromRay(org, dir, true);
+        return d === Infinity ? null : { x: org.x + dir.x * d, z: org.z + dir.z * d };
+    }
+    intersectsRay(org, dir) {
+        const d = this.distanceFromRay(org, dir);
+        return d === Infinity ? null : new vec3_1.Vec3(org.x + dir.x * d, org.y + dir.y * d, org.z + dir.z * d);
     }
-    intersectsRay(origin, direction) {
-        const d = this.distanceFromRay(origin, direction);
-        return d === Infinity ? null : new vec3_1.Vec3(origin.x + direction.x * d, origin.y + direction.y * d, origin.z + direction.z * d);
+    //TODO: Better check for hit reg of PLANES.
+    xzIntersectsSegment(org, dest) {
+        const dir = dest.clone().subtract(org).normalize();
+        const d = this.distanceFromRay(org, dir, true);
+        return d > dest.distanceTo(org) || d < 0 ? null : { x: org.x + dir.x * d, z: org.z + dir.z * d };
+    }
+    //TODO: Better check for hit reg of PLANES.
+    intersectsSegment(org, dest) {
+        const dir = dest.clone().subtract(org).normalize();
+        const d = this.distanceFromRay(org, dir);
+        return d > dest.distanceTo(org) || d < 0 ? null : new vec3_1.Vec3(org.x + dir.x * d, org.y + dir.y * d, org.z + dir.z * d);
     }
     distanceFromRay(origin, direction, xz = false) {
         const ro = origin.toArray();
-        const rd = direction.normalize().toArray();
+        const rd = direction.clone().normalize().toArray();
         const aabb = this.toMinAndMaxArrays();
         const dims = ro.length; // will change later.
         const dif = xz ? 2 : 1;
@@ -168,6 +192,12 @@ class AABB {
             this.maxY === other.maxY &&
             this.maxZ === other.maxZ);
     }
+    xzDistanceTo(pos, heightOffset = 0) {
+        const { x, y, z } = pos.offset(0, heightOffset, 0);
+        let dx = Math.max(this.minX - x, 0, x - this.maxX);
+        let dz = Math.max(this.minZ - z, 0, z - this.maxZ);
+        return Math.sqrt(dx * dx + dz * dz);
+    }
     distanceTo(pos, heightOffset = 0) {
         const { x, y, z } = pos.offset(0, heightOffset, 0);
         let dx = Math.max(this.minX - x, 0, x - this.maxX);

package/lib/calcs/intercept.d.ts

@@ -0,0 +1,25 @@
+import { Bot } from "mineflayer";
+import { Block } from "prismarine-block";
+import { Vec3 } from "vec3";
+export declare class InterceptFunctions {
+    bot: Bot;
+    constructor(bot: Bot);
+    check(from: Vec3, to: Vec3): {
+        block: Block | null;
+        iterations: {
+            x: number;
+            y: number;
+            z: number;
+            face: number;
+        }[];
+    };
+    raycast(from: Vec3, direction: Vec3, range: number): {
+        block: Block | null;
+        iterations: {
+            x: number;
+            y: number;
+            z: number;
+            face: number;
+        }[];
+    };
+}

package/lib/calcs/intercept.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptFunctions = void 0;
+const vec3_1 = require("vec3");
+class InterceptFunctions {
+    constructor(bot) {
+        this.bot = bot;
+    }
+    //Old ver grabs range between the two + direction from... from to... to.
+    //calls raycast.
+    check(from, to) {
+        //old code:
+        const range = from.distanceTo(to);
+        const direction = to.minus(from).normalize();
+        if (isNaN(range))
+            return { block: null, iterations: [] };
+        return this.raycast(from, direction, range);
+    }
+    raycast(from, direction, range) {
+        const iterations = [];
+        const iter = new RaycastIterator(from, direction, range);
+        let pos = iter.next();
+        while (pos) {
+            iterations.push(pos);
+            const position = new vec3_1.Vec3(pos.x, pos.y, pos.z);
+            const block = this.bot.blockAt(position);
+            if (block) {
+                const intersect = iter.intersect(block.shapes, position);
+                if (intersect) {
+                    return {
+                        block,
+                        iterations,
+                    };
+                }
+            }
+            pos = iter.next();
+            if (range > 20 || (iterations.length >= 1000 && iterations.length % 1000 === 0)) {
+                // console.trace("too much");
+                console.log(from, direction, range, iterations, block, position, pos);
+            }
+            // console.log(range, iterations.length);
+        }
+        return {
+            block: null,
+            iterations,
+        };
+    }
+}
+exports.InterceptFunctions = InterceptFunctions;
+var BlockFace;
+(function (BlockFace) {
+    BlockFace[BlockFace["UNKNOWN"] = -999] = "UNKNOWN";
+    BlockFace[BlockFace["BOTTOM"] = 0] = "BOTTOM";
+    BlockFace[BlockFace["TOP"] = 1] = "TOP";
+    BlockFace[BlockFace["NORTH"] = 2] = "NORTH";
+    BlockFace[BlockFace["SOUTH"] = 3] = "SOUTH";
+    BlockFace[BlockFace["WEST"] = 4] = "WEST";
+    BlockFace[BlockFace["EAST"] = 5] = "EAST";
+})(BlockFace || (BlockFace = {}));
+class RaycastIterator {
+    constructor(pos, dir, maxDistance) {
+        this.block = {
+            x: Math.floor(pos.x),
+            y: Math.floor(pos.y),
+            z: Math.floor(pos.z),
+            face: BlockFace.UNKNOWN,
+        };
+        this.blockVec = new vec3_1.Vec3(Math.floor(pos.x), Math.floor(pos.y), Math.floor(pos.z));
+        this.pos = pos;
+        this.dir = dir;
+        this.invDirX = dir.x === 0 ? Number.MAX_VALUE : 1 / dir.x;
+        this.invDirY = dir.y === 0 ? Number.MAX_VALUE : 1 / dir.y;
+        this.invDirZ = dir.z === 0 ? Number.MAX_VALUE : 1 / dir.z;
+        this.stepX = Math.sign(dir.x);
+        this.stepY = Math.sign(dir.y);
+        this.stepZ = Math.sign(dir.z);
+        this.tDeltaX = dir.x === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.x);
+        this.tDeltaY = dir.y === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.y);
+        this.tDeltaZ = dir.z === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.z);
+        this.tMaxX = dir.x === 0 ? Number.MAX_VALUE : Math.abs((this.block.x + (dir.x > 0 ? 1 : 0) - pos.x) / dir.x);
+        this.tMaxY = dir.y === 0 ? Number.MAX_VALUE : Math.abs((this.block.y + (dir.y > 0 ? 1 : 0) - pos.y) / dir.y);
+        this.tMaxZ = dir.z === 0 ? Number.MAX_VALUE : Math.abs((this.block.z + (dir.z > 0 ? 1 : 0) - pos.z) / dir.z);
+        this.maxDistance = maxDistance;
+    }
+    // Returns null if none of the shapes is intersected, otherwise returns intersect pos and face
+    // shapes are translated by offset
+    //[x0: number,y0: number,z0: number,x1:number,y1:number,z1:number][]
+    intersect(shapes, offset) {
+        // Shapes is an array of shapes, each in the form of: [x0, y0, z0, x1, y1, z1]
+        let t = Number.MAX_VALUE;
+        let f = BlockFace.UNKNOWN;
+        const p = this.pos.minus(offset);
+        for (const shape of shapes) {
+            let tmin = (shape[this.invDirX > 0 ? 0 : 3] - p.x) * this.invDirX;
+            let tmax = (shape[this.invDirX > 0 ? 3 : 0] - p.x) * this.invDirX;
+            const tymin = (shape[this.invDirY > 0 ? 1 : 4] - p.y) * this.invDirY;
+            const tymax = (shape[this.invDirY > 0 ? 4 : 1] - p.y) * this.invDirY;
+            let face = this.stepX > 0 ? BlockFace.WEST : BlockFace.EAST;
+            if (tmin > tymax || tymin > tmax)
+                continue;
+            if (tymin > tmin) {
+                tmin = tymin;
+                face = this.stepY > 0 ? BlockFace.BOTTOM : BlockFace.TOP;
+            }
+            if (tymax < tmax)
+                tmax = tymax;
+            const tzmin = (shape[this.invDirZ > 0 ? 2 : 5] - p.z) * this.invDirZ;
+            const tzmax = (shape[this.invDirZ > 0 ? 5 : 2] - p.z) * this.invDirZ;
+            if (tmin > tzmax || tzmin > tmax)
+                continue;
+            if (tzmin > tmin) {
+                tmin = tzmin;
+                face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+            if (tzmax < tmax)
+                tmax = tzmax;
+            if (tmin < t) {
+                t = tmin;
+                f = face;
+            }
+        }
+        if (t === Number.MAX_VALUE)
+            return null;
+        return { pos: this.pos.plus(this.dir.scaled(t)), face: f };
+    }
+    next() {
+        if (Math.min(Math.min(this.tMaxX, this.tMaxY), this.tMaxZ) > this.maxDistance) {
+            return null;
+        }
+        if (this.tMaxX < this.tMaxY) {
+            if (this.tMaxX < this.tMaxZ) {
+                this.block.x += this.stepX;
+                this.tMaxX += this.tDeltaX;
+                this.block.face = this.stepX > 0 ? BlockFace.WEST : BlockFace.EAST;
+            }
+            else {
+                this.block.z += this.stepZ;
+                this.tMaxZ += this.tDeltaZ;
+                this.block.face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+        }
+        else {
+            if (this.tMaxY < this.tMaxZ) {
+                this.block.y += this.stepY;
+                this.tMaxY += this.tDeltaY;
+                this.block.face = this.stepY > 0 ? BlockFace.BOTTOM : BlockFace.TOP;
+            }
+            else {
+                this.block.z += this.stepZ;
+                this.tMaxZ += this.tDeltaZ;
+                this.block.face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+        }
+        if (isNaN(this.block.x) || isNaN(this.block.y) || isNaN(this.block.z))
+            return null;
+        return this.block;
+    }
+}

package/lib/index.d.ts

@@ -26,3 +26,4 @@ declare module "prismarine-entity" {
 }
 export default function inject(bot: Bot): void;
 export { AABB } from "./calcs/aabb";
+export { InterceptFunctions } from "./calcs/intercept";

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AABB = void 0;
+exports.InterceptFunctions = exports.AABB = void 0;
 const utilFunctions_1 = require("./utilFunctions");
 function inject(bot) {
     bot.util = new utilFunctions_1.UtilFunctions(bot);
@@ -8,3 +8,5 @@ function inject(bot) {
 exports.default = inject;
 var aabb_1 = require("./calcs/aabb");
 Object.defineProperty(exports, "AABB", { enumerable: true, get: function () { return aabb_1.AABB; } });
+var intercept_1 = require("./calcs/intercept");
+Object.defineProperty(exports, "InterceptFunctions", { enumerable: true, get: function () { return intercept_1.InterceptFunctions; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nxg-org/mineflayer-util-plugin",
-    "version": "1.3.2",
+    "version": "1.3.7",
     "description": "mineflayer utils for NextGEN mineflayer plugins.",
     "keywords": [
         "mineflayer",