@nxg-org/mineflayer-util-plugin 1.3.5 → 1.3.9

package/lib/calcs/intercept.d.ts

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

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,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AABB = void 0;
+exports.InterceptFunctions = exports.AABB = void 0;
 const utilFunctions_1 = require("./utilFunctions");
+const mineflayer_pathfinder_1 = require("mineflayer-pathfinder");
 function inject(bot) {
+    if (!bot.pathfinder)
+        bot.loadPlugin(mineflayer_pathfinder_1.pathfinder);
     bot.util = new utilFunctions_1.UtilFunctions(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/lib/inventoryFunctions.js

@@ -90,18 +90,17 @@ class InventoryFunctions {
     }
     findItemByID(itemId, metadata) {
         var _a, _b;
-        const potentialMatches = this.getAllItems().filter((item) => item.type === itemId);
         if (metadata)
-            return (_a = potentialMatches.find((item) => item.metadata === metadata)) !== null && _a !== void 0 ? _a : null;
-        return (_b = potentialMatches[0]) !== null && _b !== void 0 ? _b : null;
+            return (_a = this.getAllItems().find((item) => item.type === itemId && item.metadata === metadata)) !== null && _a !== void 0 ? _a : null;
+        else
+            return (_b = this.getAllItems().find((item) => item.type === itemId)) !== null && _b !== void 0 ? _b : null;
     }
     findItem(name, metadata) {
         var _a, _b;
-        //[...this.getAllItems(), this.bot.inventory.selectedItem!]
-        const potentialMatches = this.getAllItems().filter((item) => item === null || item === void 0 ? void 0 : item.name.includes(name));
         if (metadata)
-            return (_a = potentialMatches.find((item) => item.metadata === metadata)) !== null && _a !== void 0 ? _a : null;
-        return (_b = potentialMatches[0]) !== null && _b !== void 0 ? _b : null;
+            return (_a = this.getAllItems().find((item) => item.name === name && item.metadata === metadata)) !== null && _a !== void 0 ? _a : null;
+        else
+            return (_b = this.getAllItems().find((item) => item.name === name)) !== null && _b !== void 0 ? _b : null;
     }
     //alias.
     has(name, metadata) {

package/lib/movementFunctions.js

@@ -100,7 +100,7 @@ class MovementFunctions {
             if (update) {
                 // this.bot.entity.yaw = yaw;
                 // this.bot.entity.pitch = pitch
-                this.bot.lookAt(pos, true);
+                this.bot.look(yaw, pitch, true);
             }
         }
     }

package/lib/predictiveFunctions.js

@@ -91,15 +91,21 @@ const AIR_BLOCK = { type: 0 };
 class PredictiveFunctions {
     constructor(bot) {
         this.bot = bot;
-        this.damageMultiplier = 7; // for 1.12+ 8 for 1.8 TODO check when the change occur (likely 1.9)
         this.resistanceIndex = "11";
-        if (require('minecraft-data')(bot.version).isNewerOrEqualTo("1.16")) {
+        const version = Number(bot.version.split(".")[1]);
+        if (version === 16) {
             this.armorToughnessKey = "generic.armorToughness";
             this.armorProtectionKey = "generic.armor";
         }
         else {
-            this.armorToughnessKey = "generic.armorToughness";
-            this.armorProtectionKey = "generic.armor";
+            this.armorToughnessKey = "minecraft:generic.armor_toughness";
+            this.armorProtectionKey = "minecraft:generic.armor";
+        }
+        if (version > 9) {
+            this.damageMultiplier = 8;
+        }
+        else {
+            this.damageMultiplier = 7;
         }
         const effects = (0, minecraft_data_1.default)(bot.version).effects;
         for (const effectId in effects) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nxg-org/mineflayer-util-plugin",
-    "version": "1.3.5",
+    "version": "1.3.9",
     "description": "mineflayer utils for NextGEN mineflayer plugins.",
     "keywords": [
         "mineflayer",
@@ -28,7 +28,7 @@
         "vec3": "^0.1.7"
     },
     "devDependencies": {
-        "@types/node": "^16.11.11",
+        "@types/node": "^17.0.4",
         "typescript": "^4.5.2"
     }
 }