@nxg-org/mineflayer-util-plugin 1.7.9 → 1.7.11

package/lib/calcs/aabb.d.ts

@@ -1,4 +1,9 @@
 import { Vec3 } from "vec3";
+type FakeVec3 = {
+    x: number;
+    y: number;
+    z: number;
+};
 type AABBPoints = [minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number];
 type MinAndMaxPoints = [min: [x: number, y: number, z: number], max: [x: number, y: number, z: number]];
 type Vec3AABB = [min: Vec3, max: Vec3];
@@ -10,8 +15,8 @@ export declare class AABB {
     maxY: number;
     maxZ: number;
     constructor(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number);
-    static fromVecs(min: Vec3, max: Vec3): AABB;
-    static fromBlock(min: Vec3): AABB;
+    static fromVecs(min: FakeVec3, max: FakeVec3): AABB;
+    static fromBlock(min: FakeVec3): AABB;
     static fromShape(pts: AABBPoints, offset?: Vec3): AABB;
     set(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
     clone(): AABB;
@@ -40,7 +45,7 @@ export declare class AABB {
     contract(x: number, y: number, z: number): this;
     expand(x: number, y: number, z: number): this;
     translate(x: number, y: number, z: number): this;
-    translateVec(vec: Vec3): this;
+    translateVec(vec: FakeVec3): this;
     computeOffsetX(other: AABB, offsetX: number): number;
     computeOffsetY(other: AABB, offsetY: number): number;
     computeOffsetZ(other: AABB, offsetZ: number): number;
@@ -58,15 +63,17 @@ export declare class AABB {
     distanceFromRay(origin: Vec3, direction: Vec3, xz?: boolean): number;
     intersect(aABB: AABB): AABB;
     equals(other: AABB): boolean;
-    xzDistanceToVec(pos: Vec3): number;
-    distanceToVec(pos: Vec3): number;
-    expandTowards(vec3: Vec3): AABB;
+    xzDistanceToVec(pos: FakeVec3): number;
+    distanceToVec(pos: FakeVec3): number;
+    expandTowards(vec3: FakeVec3): AABB;
     expandTowardsCoords(d: number, d2: number, d3: number): AABB;
     moveCoords(d: number, d2: number, d3: number): AABB;
-    move(vec3: Vec3): AABB;
+    move(vec3: FakeVec3): AABB;
     intersectsCoords(d: number, d2: number, d3: number, d4: number, d5: number, d6: number): boolean;
-    collidesAABB(aABB: AABB): boolean;
+    collides(aABB: AABB): boolean;
     collidesCoords(d: number, d2: number, d3: number, d4: number, d5: number, d6: number): boolean;
+    containsVec(vec: FakeVec3): boolean;
+    contains(x: number, y: number, z: number): boolean;
     getCenter(): Vec3;
 }
 export default AABB;

package/lib/calcs/aabb.js

@@ -304,12 +304,23 @@ class AABB {
     intersectsCoords(d, d2, d3, d4, d5, d6) {
         return this.minX < d4 && this.maxX > d && this.minY < d5 && this.maxY > d2 && this.minZ < d6 && this.maxZ > d3;
     }
-    collidesAABB(aABB) {
+    collides(aABB) {
         return this.collidesCoords(aABB.minX, aABB.minY, aABB.minZ, aABB.maxX, aABB.maxY, aABB.maxZ);
     }
     collidesCoords(d, d2, d3, d4, d5, d6) {
         return (this.minX <= d4 && this.maxX >= d && this.minY <= d5 && this.maxY >= d2 && this.minZ <= d6 && this.maxZ >= d3);
     }
+    containsVec(vec) {
+        return (this.minX <= vec.x &&
+            this.maxX >= vec.x &&
+            this.minY <= vec.y &&
+            this.maxY >= vec.y &&
+            this.minZ <= vec.z &&
+            this.maxZ >= vec.z);
+    }
+    contains(x, y, z) {
+        return this.minX <= x && this.maxX >= x && this.minY <= y && this.maxY >= y && this.minZ <= z && this.maxZ >= z;
+    }
     getCenter() {
         return new vec3_1.Vec3(lerp(0.5, this.minX, this.maxX), lerp(0.5, this.minY, this.maxY), lerp(0.5, this.minZ, this.maxZ));
     }

package/lib/static/mathUtil.d.ts

@@ -24,5 +24,6 @@ export declare namespace MathUtils {
         pitch: number;
     };
     function getYaw(origin: Vec3, destination: Vec3): number;
+    function getViewDir(pitch: number, yaw: number): Vec3;
     function yawPitchAndSpeedToDir(yaw: number, pitch: number, speed: number): Vec3;
 }

package/lib/static/mathUtil.js

@@ -59,6 +59,10 @@ var MathUtils;
         return yaw;
     }
     MathUtils.getYaw = getYaw;
+    function getViewDir(pitch, yaw) {
+        return new vec3_1.Vec3(-Math.sin(yaw) * Math.cos(pitch), Math.sin(pitch), -Math.cos(yaw) * Math.cos(pitch));
+    }
+    MathUtils.getViewDir = getViewDir;
     function yawPitchAndSpeedToDir(yaw, pitch, speed) {
         return new vec3_1.Vec3(-Math.sin(yaw) * Math.cos(pitch), Math.sin(pitch), -Math.cos(yaw) * Math.cos(pitch)).scale(speed);
     }

package/lib/utilFunctions.d.ts

@@ -1,18 +1,11 @@
 import type { Bot } from "mineflayer";
+import { Vec3 } from "vec3";
 import { EntityFunctions } from "./entityFunctions";
 import { FilterFunctions } from "./filterFunctions";
 import { InventoryFunctions } from "./inventoryFunctions";
 import { MovementFunctions } from "./movementFunctions";
 import { PredictiveFunctions } from "./predictiveFunctions";
 import { RayTraceFunctions } from "./rayTracingFunctions";
-/**
- * I don't believe I need any locks, as I'm only going to have one instance of this per bot.
- * This is added to bot context so multiple instances will exist in memory.
- * Therefore, I don't need this. https://www.npmjs.com/package/async-lock
- */
-/**
- * I may add listeners to this class, as halting until an item is equipped may be good.
- */
 /**
  * I can't inherit from multiple classes. This language sucks.
  * I'm not using mixins. Fuck you, fuck that.
@@ -29,4 +22,5 @@ export declare class UtilFunctions {
     filters: FilterFunctions;
     raytrace: RayTraceFunctions;
     constructor(bot: Bot);
+    getViewDir(): Vec3;
 }

package/lib/utilFunctions.js

@@ -1,20 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFunctions = void 0;
+const vec3_1 = require("vec3");
 const entityFunctions_1 = require("./entityFunctions");
 const filterFunctions_1 = require("./filterFunctions");
 const inventoryFunctions_1 = require("./inventoryFunctions");
 const movementFunctions_1 = require("./movementFunctions");
 const predictiveFunctions_1 = require("./predictiveFunctions");
 const rayTracingFunctions_1 = require("./rayTracingFunctions");
-/**
- * I don't believe I need any locks, as I'm only going to have one instance of this per bot.
- * This is added to bot context so multiple instances will exist in memory.
- * Therefore, I don't need this. https://www.npmjs.com/package/async-lock
- */
-/**
- * I may add listeners to this class, as halting until an item is equipped may be good.
- */
 /**
  * I can't inherit from multiple classes. This language sucks.
  * I'm not using mixins. Fuck you, fuck that.
@@ -32,5 +25,8 @@ class UtilFunctions {
         this.filters = new filterFunctions_1.FilterFunctions(bot);
         this.raytrace = new rayTracingFunctions_1.RayTraceFunctions(bot);
     }
+    getViewDir() {
+        return new vec3_1.Vec3(-Math.sin(this.bot.entity.yaw) * Math.cos(this.bot.entity.pitch), Math.sin(this.bot.entity.pitch), -Math.cos(this.bot.entity.yaw) * Math.cos(this.bot.entity.pitch));
+    }
 }
 exports.UtilFunctions = UtilFunctions;

package/package.json

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