@nxg-org/mineflayer-util-plugin 1.3.12 → 1.3.13

package/lib/entityFunctions.d.ts

@@ -41,9 +41,18 @@ export declare class EntityFunctions {
     getDistanceToEntity(entity: Entity): number;
     getDistanceBetweenEntities(first: Entity, second: Entity): number;
     getEntityAABB(entity: {
+        type: string;
         position: Vec3;
         height: number;
         width?: number;
     }): AABB;
+    getPlayerAABB(entity: {
+        position: Vec3;
+    }): AABB;
+    getEntityAABBRaw(entity: {
+        position: Vec3;
+        height: number;
+        width: number;
+    }): AABB;
     private parseMetadata;
 }

package/lib/entityFunctions.js

@@ -87,7 +87,19 @@ class EntityFunctions {
     }
     getEntityAABB(entity) {
         var _a;
-        const w = (_a = entity.width) !== null && _a !== void 0 ? _a : entity.height / 2;
+        switch (entity.type) {
+            case "player":
+                return this.getPlayerAABB({ position: entity.position });
+            case "mob":
+            default: //TODO: Implement better AABBs. However, this may just be correct.
+                return this.getEntityAABBRaw({ position: entity.position, height: entity.height, width: (_a = entity.width) !== null && _a !== void 0 ? _a : entity.height });
+        }
+    }
+    getPlayerAABB(entity) {
+        return this.getEntityAABBRaw({ position: entity.position, height: 1.8, width: 0.3 });
+    }
+    getEntityAABBRaw(entity) {
+        const w = entity.width / 2;
         const { x, y, z } = entity.position;
         return new aabb_1.AABB(-w, 0, -w, w, entity.height, w).offset(x, y, z);
     }

package/lib/index.d.ts

@@ -15,15 +15,8 @@ declare module "mineflayer" {
     }
 }
 declare module "prismarine-entity" {
-    interface Entity {
-        attributes: {
-            [index: string]: {
-                value: number;
-                modifiers: any[];
-            };
-        };
-    }
 }
 export default function inject(bot: Bot): void;
 export { AABB } from "./calcs/aabb";
 export { InterceptFunctions } from "./calcs/intercept";
+export { AABBUtils, MathUtils } from "./static";

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InterceptFunctions = exports.AABB = void 0;
+exports.MathUtils = exports.AABBUtils = exports.InterceptFunctions = exports.AABB = void 0;
 const utilFunctions_1 = require("./utilFunctions");
 const mineflayer_pathfinder_1 = require("mineflayer-pathfinder");
 function inject(bot) {
@@ -13,3 +13,6 @@ 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; } });
+var static_1 = require("./static");
+Object.defineProperty(exports, "AABBUtils", { enumerable: true, get: function () { return static_1.AABBUtils; } });
+Object.defineProperty(exports, "MathUtils", { enumerable: true, get: function () { return static_1.MathUtils; } });

package/lib/static/aabbUtil.d.ts

@@ -0,0 +1,21 @@
+import type { Block } from "prismarine-block";
+import { AABB } from "../calcs/aabb";
+import type { Vec3 } from "vec3";
+export declare namespace AABBUtils {
+    function getBlockAABB(block: Block, height?: number): AABB;
+    function getBlockPosAABB(block: Vec3, height?: number): AABB;
+    function getEntityAABB(entity: {
+        type: string;
+        position: Vec3;
+        height: number;
+        width?: number;
+    }): AABB;
+    function getPlayerAABB(entity: {
+        position: Vec3;
+    }): AABB;
+    function getEntityAABBRaw(entity: {
+        position: Vec3;
+        height: number;
+        width: number;
+    }): AABB;
+}

package/lib/static/aabbUtil.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AABBUtils = void 0;
+const aabb_1 = require("../calcs/aabb");
+var AABBUtils;
+(function (AABBUtils) {
+    function getBlockAABB(block, height = 1) {
+        const { x, y, z } = block.position;
+        return new aabb_1.AABB(x, y, z, x + 1, y + height, z + 1);
+    }
+    AABBUtils.getBlockAABB = getBlockAABB;
+    function getBlockPosAABB(block, height = 1) {
+        const { x, y, z } = block.floored();
+        return new aabb_1.AABB(x, y, z, x + 1, y + height, z + 1);
+    }
+    AABBUtils.getBlockPosAABB = getBlockPosAABB;
+    function getEntityAABB(entity) {
+        var _a;
+        switch (entity.type) {
+            case "player":
+                return getPlayerAABB({ position: entity.position });
+            case "mob":
+            default: //TODO: Implement better AABBs. However, this may just be correct.
+                return getEntityAABBRaw({ position: entity.position, height: entity.height, width: (_a = entity.width) !== null && _a !== void 0 ? _a : entity.height });
+        }
+    }
+    AABBUtils.getEntityAABB = getEntityAABB;
+    function getPlayerAABB(entity) {
+        return getEntityAABBRaw({ position: entity.position, height: 1.8, width: 0.3 });
+    }
+    AABBUtils.getPlayerAABB = getPlayerAABB;
+    function getEntityAABBRaw(entity) {
+        const w = entity.width / 2;
+        const { x, y, z } = entity.position;
+        return new aabb_1.AABB(-w, 0, -w, w, entity.height, w).offset(x, y, z);
+    }
+    AABBUtils.getEntityAABBRaw = getEntityAABBRaw;
+})(AABBUtils = exports.AABBUtils || (exports.AABBUtils = {}));

package/lib/static/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./aabbUtil";
+export * from "./mathUtil";

package/lib/static/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aabbUtil"), exports);
+__exportStar(require("./mathUtil"), exports);

package/lib/static/mathUtil.d.ts

@@ -0,0 +1,24 @@
+import { Bot } from "mineflayer";
+import { Vec3 } from "vec3";
+export declare namespace MathUtils {
+    const toNotchianYaw: (yaw: number) => number;
+    const toNotchianPitch: (pitch: number) => number;
+    const fromNotchianYawByte: (yaw: number) => number;
+    const fromNotchianPitchByte: (pitch: number) => number;
+    function euclideanMod(numerator: number, denominator: number): number;
+    function toRadians(degrees: number): number;
+    function toDegrees(radians: number): number;
+    function fromNotchianYaw(yaw: number): number;
+    function fromNotchianPitch(pitch: number): number;
+    function fromNotchVelocity(vel: Vec3): Vec3;
+    function pointToYawAndPitch(bot: Bot, point: Vec3): {
+        yaw: number;
+        pitch: number;
+    };
+    function dirToYawAndPitch(dir: Vec3): {
+        yaw: number;
+        pitch: number;
+    };
+    function getYaw(origin: Vec3, destination: Vec3): number;
+    function yawPitchAndSpeedToDir(yaw: number, pitch: number, speed: number): Vec3;
+}

package/lib/static/mathUtil.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathUtils = void 0;
+const vec3_1 = require("vec3");
+const PI = Math.PI;
+const PI_2 = Math.PI * 2;
+const TO_RAD = PI / 180;
+const TO_DEG = 1 / TO_RAD;
+const FROM_NOTCH_BYTE = 360 / 256;
+// From wiki.vg: Velocity is believed to be in units of 1/8000 of a block per server tick (50ms)
+const FROM_NOTCH_VEL = 1 / 8000;
+var MathUtils;
+(function (MathUtils) {
+    MathUtils.toNotchianYaw = (yaw) => toDegrees(PI - yaw);
+    MathUtils.toNotchianPitch = (pitch) => toDegrees(-pitch);
+    MathUtils.fromNotchianYawByte = (yaw) => fromNotchianYaw(yaw * FROM_NOTCH_BYTE);
+    MathUtils.fromNotchianPitchByte = (pitch) => fromNotchianPitch(pitch * FROM_NOTCH_BYTE);
+    function euclideanMod(numerator, denominator) {
+        const result = numerator % denominator;
+        return result < 0 ? result + denominator : result;
+    }
+    MathUtils.euclideanMod = euclideanMod;
+    function toRadians(degrees) {
+        return TO_RAD * degrees;
+    }
+    MathUtils.toRadians = toRadians;
+    function toDegrees(radians) {
+        return TO_DEG * radians;
+    }
+    MathUtils.toDegrees = toDegrees;
+    function fromNotchianYaw(yaw) {
+        return euclideanMod(PI - toRadians(yaw), PI_2);
+    }
+    MathUtils.fromNotchianYaw = fromNotchianYaw;
+    function fromNotchianPitch(pitch) {
+        return euclideanMod(toRadians(-pitch) + PI, PI_2) - PI;
+    }
+    MathUtils.fromNotchianPitch = fromNotchianPitch;
+    function fromNotchVelocity(vel) {
+        return new vec3_1.Vec3(vel.x * FROM_NOTCH_VEL, vel.y * FROM_NOTCH_VEL, vel.z * FROM_NOTCH_VEL);
+    }
+    MathUtils.fromNotchVelocity = fromNotchVelocity;
+    function pointToYawAndPitch(bot, point) {
+        const delta = point.minus(bot.entity.position.offset(0, bot.entity.height, 0));
+        return dirToYawAndPitch(delta);
+    }
+    MathUtils.pointToYawAndPitch = pointToYawAndPitch;
+    function dirToYawAndPitch(dir) {
+        const yaw = Math.atan2(-dir.x, -dir.z);
+        const groundDistance = Math.sqrt(dir.x * dir.x + dir.z * dir.z);
+        const pitch = Math.atan2(dir.y, groundDistance);
+        return { yaw: yaw, pitch: pitch };
+    }
+    MathUtils.dirToYawAndPitch = dirToYawAndPitch;
+    function getYaw(origin, destination) {
+        const xDistance = destination.x - origin.x;
+        const zDistance = destination.z - origin.z;
+        const yaw = Math.atan2(xDistance, zDistance) + Math.PI;
+        return yaw;
+    }
+    MathUtils.getYaw = getYaw;
+    //Scuffed.
+    function yawPitchAndSpeedToDir(yaw, pitch, speed) {
+        const thetaY = PI + yaw;
+        const thetaP = pitch;
+        const x = speed * Math.sin(thetaY);
+        const y = speed * Math.sin(thetaP);
+        const z = speed * Math.cos(thetaY);
+        const VxMag = Math.sqrt(x * x + z * z);
+        const VxRatio = Math.sqrt(VxMag * VxMag - y * y);
+        const allRatio = VxRatio / VxMag;
+        return new vec3_1.Vec3(x * allRatio, y, z * allRatio);
+    }
+    MathUtils.yawPitchAndSpeedToDir = yawPitchAndSpeedToDir;
+})(MathUtils = exports.MathUtils || (exports.MathUtils = {}));

package/package.json

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