@nxg-org/mineflayer-util-plugin 1.2.6 → 1.3.3

package/lib/calcs/aabb.d.ts

@@ -28,9 +28,19 @@ export declare class AABB {
     computeOffsetY(other: AABB, offsetY: number): number;
     computeOffsetZ(other: AABB, offsetZ: number): number;
     intersects(other: AABB): boolean;
-    intersectsRay(origin: Vec3, direction: Vec3): Vec3 | null;
-    distanceFromRay(origin: Vec3, direction: Vec3): number;
+    xzIntersectsRay(org: Vec3, dir: Vec3): {
+        x: number;
+        z: number;
+    } | 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

@@ -125,24 +125,36 @@ class AABB {
             this.minZ < other.maxZ &&
             this.maxZ > other.minZ);
     }
-    intersectsRay(origin, direction) {
-        const d = this.distanceFromRay(origin, direction);
-        if (d === Infinity) {
-            return null;
-        }
-        else {
-            return new vec3_1.Vec3(origin.x + direction.x * d, origin.y + direction.y * d, origin.z + direction.z * d);
-        }
-    }
-    distanceFromRay(origin, direction) {
+    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);
+    }
+    //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;
         let lo = -Infinity;
         let hi = +Infinity;
         // let test = origin.clone()
-        for (let i = 0; i < dims; i++) {
+        for (let i = 0; i < dims; i += dif) {
             let dimLo = (aabb[0][i] - ro[i]) / rd[i];
             let dimHi = (aabb[1][i] - ro[i]) / rd[i];
             if (dimLo > dimHi) {
@@ -150,21 +162,7 @@ class AABB {
                 dimLo = dimHi;
                 dimHi = tmp;
             }
-            // let num;
-            // switch (i) {
-            //     case 0:
-            //         num = "x"
-            //         break;
-            //     case 1:
-            //         num = "y"
-            //         break;
-            //     case 2:
-            //         num = "z"
-            //         break;
-            // }
-            // console.log(num, aabb[0][i], aabb[1][i], ro[i], "highest overall:", lo, hi )
             if (dimHi < lo || dimLo > hi) {
-                console.log("fuck", dimHi < lo, dimLo > hi);
                 return Infinity;
             }
             if (dimLo > lo)
@@ -182,6 +180,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/rayTracingFunctions.d.ts

@@ -0,0 +1,15 @@
+import { Bot } from "mineflayer";
+import { Vec3 } from "vec3";
+import type { Entity } from "prismarine-entity";
+export declare class RayTraceFunctions {
+    private bot;
+    constructor(bot: Bot);
+    blockAtEntityCursor({ position, height, yaw, pitch }: {
+        position: Vec3;
+        height: number;
+        yaw: number;
+        pitch: number;
+    }, maxDistance?: number, matcher?: null): any;
+    entityAtCursor(maxDistance?: number): Entity | null;
+    entityAtEntityCursor(entity: Entity, maxDistance?: number): Entity | null;
+}

package/lib/rayTracingFunctions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RayTraceFunctions = void 0;
+const vec3_1 = require("vec3");
+const iterators_1 = require("./calcs/iterators");
+function getViewDirection(pitch, yaw) {
+    const csPitch = Math.cos(pitch);
+    const snPitch = Math.sin(pitch);
+    const csYaw = Math.cos(yaw);
+    const snYaw = Math.sin(yaw);
+    return new vec3_1.Vec3(-snYaw * csPitch, snPitch, -csYaw * csPitch);
+}
+class RayTraceFunctions {
+    constructor(bot) {
+        this.bot = bot;
+    }
+    blockAtEntityCursor({ position, height, yaw, pitch }, maxDistance = 256, matcher = null) {
+        const eyePosition = position.offset(0, height, 0);
+        const viewDirection = getViewDirection(pitch, yaw);
+        return this.bot.world.raycast(eyePosition, viewDirection, maxDistance, matcher);
+    }
+    entityAtCursor(maxDistance = 3.5) {
+        return this.entityAtEntityCursor(this.bot.entity, maxDistance);
+    }
+    entityAtEntityCursor(entity, maxDistance = 3.5) {
+        var _a;
+        const block = this.blockAtEntityCursor(entity, maxDistance);
+        maxDistance = (_a = block === null || block === void 0 ? void 0 : block.intersect.distanceTo(this.bot.entity.position)) !== null && _a !== void 0 ? _a : maxDistance;
+        const entities = Object.values(this.bot.entities).filter((e) => e.type !== "object" && e.username !== entity.username && e.position.distanceTo(entity.position) <= maxDistance);
+        const dir = new vec3_1.Vec3(-Math.sin(entity.yaw) * Math.cos(entity.pitch), Math.sin(entity.pitch), -Math.cos(entity.yaw) * Math.cos(entity.pitch));
+        const iterator = new iterators_1.RaycastIterator(entity.position.offset(0, entity.height, 0), dir.normalize(), maxDistance);
+        let targetEntity = null;
+        let targetDist = maxDistance;
+        for (let i = 0; i < entities.length; i++) {
+            const e = entities[i];
+            const w = e.height >= 1.62 && e.height <= 1.99 || e.height === 2.9 ? 0.3 : e.height / 2;
+            const shapes = [[-w, 0, -w, w, e.height + (e.height === 1.62 ? 0.18 : 0), w]];
+            const intersect = iterator.intersect(shapes, e.position);
+            if (intersect) {
+                const entityDir = e.position.minus(entity.position); // Can be combined into 1 line
+                const sign = Math.sign(entityDir.dot(dir));
+                if (sign !== -1) {
+                    const dist = entity.position.distanceTo(intersect.pos);
+                    if (dist < targetDist) {
+                        targetEntity = e;
+                        targetDist = dist;
+                    }
+                }
+            }
+        }
+        return targetEntity;
+    }
+}
+exports.RayTraceFunctions = RayTraceFunctions;

package/lib/types/entities.js

@@ -0,0 +1 @@
+"use strict";

package/lib/utilFunctions.d.ts

@@ -7,6 +7,7 @@ import { MovementFunctions } from "./movementFunctions";
 import { PredictiveFunctions } from "./predictiveFunctions";
 import { MathFunctions } from "./mathUtil";
 import { WorldFunctions } from "./WorldFunctions";
+import { RayTraceFunctions } from "./rayTracingFunctions";
 export declare type BuiltInPriorityOptions = {
     group: PrioGroups;
     priority: number;
@@ -28,6 +29,7 @@ export declare class UtilFunctions {
     filters: FilterFunctions;
     math: MathFunctions;
     world: WorldFunctions;
+    raytrace: RayTraceFunctions;
     private builtInsPriorityStore;
     private customPriorityStore;
     private builtInCurrentExecuting;

package/lib/utilFunctions.js

@@ -18,6 +18,7 @@ const util_1 = require("util");
 const predictiveFunctions_1 = require("./predictiveFunctions");
 const mathUtil_1 = require("./mathUtil");
 const WorldFunctions_1 = require("./WorldFunctions");
+const rayTracingFunctions_1 = require("./rayTracingFunctions");
 class UtilFunctions {
     constructor(bot) {
         this.bot = bot;
@@ -28,6 +29,7 @@ class UtilFunctions {
         this.predict = new predictiveFunctions_1.PredictiveFunctions(bot);
         this.filters = new filterFunctions_1.FilterFunctions(bot);
         this.world = new WorldFunctions_1.WorldFunctions(bot);
+        this.raytrace = new rayTracingFunctions_1.RayTraceFunctions(bot);
         this.math = new mathUtil_1.MathFunctions();
         this.builtInsPriorityStore = {};
         this.customPriorityStore = {};

package/lib/worldRelated/predictiveWorld.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictiveWorld = void 0;
 const vec3_1 = require("vec3");
-const raycastIterator_1 = require("./raycastIterator");
+const iterators_1 = require("../calcs/iterators");
 /**
  * A class dedicated to predictive logic.
  *
@@ -14,7 +14,7 @@ class PredictiveWorld {
         this.blocks = {};
     }
     raycast(from, direction, range, matcher = null) {
-        const iter = new raycastIterator_1.RaycastIterator(from, direction, range);
+        const iter = new iterators_1.RaycastIterator(from, direction, range);
         let pos = iter.next();
         while (pos) {
             const position = new vec3_1.Vec3(pos.x, pos.y, pos.z);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nxg-org/mineflayer-util-plugin",
-    "version": "1.2.6",
+    "version": "1.3.3",
     "description": "mineflayer utils for NextGEN mineflayer plugins.",
     "keywords": [
         "mineflayer",
@@ -23,6 +23,7 @@
         "mineflayer": "^3.11.2",
         "mineflayer-pathfinder": "^1.8.0",
         "prismarine-block": "^1.10.3",
+        "prismarine-entity": "^1.2.0",
         "prismarine-item": "^1.11.1",
         "vec3": "^0.1.7"
     },