@nxg-org/mineflayer-util-plugin 1.6.3 → 1.7.0

package/lib/calcs/aabb.d.ts

@@ -1,7 +1,7 @@
 import { Vec3 } from "vec3";
-declare type AABBPoints = [minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number];
-declare type MinAndMaxPoints = [min: [x: number, y: number, z: number], max: [x: number, y: number, z: number]];
-declare type Vec3AABB = [min: Vec3, max: Vec3];
+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];
 export declare class AABB {
     minX: number;
     minY: number;
@@ -14,15 +14,32 @@ export declare class AABB {
     static fromBlock(min: Vec3): AABB;
     set(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
     clone(): AABB;
+    minPoint(): Vec3;
+    maxPoint(): Vec3;
+    bottomMiddlePoint(): Vec3;
+    heightAndWidths(): Vec3;
     toArray(): AABBPoints;
-    toMinAndMaxArrays(): MinAndMaxPoints;
+    minAndMaxArrays(): MinAndMaxPoints;
     toVecs(): Vec3AABB;
+    /**
+     * Compatible with Iterators from prismarine-world.
+     * Used like a block for prismarine-world.
+     * @returns {number[][]} single element long array of shapes.
+     */
+    toShapeFromMin(): AABBPoints[];
+    /**
+     * Compatible with Iterators from prismarine-world.
+     * Used with the entity's actual position for prismarine-world.
+     * @returns {number[][]} single element long array of shapes.
+     */
+    toShapeFromBottomMiddle(): AABBPoints[];
     toVertices(): Vec3[];
     floor(): this;
     extend(dx: number, dy: number, dz: number): this;
     contract(x: number, y: number, z: number): this;
     expand(x: number, y: number, z: number): this;
     offset(x: number, y: number, z: number): this;
+    offsetVec(vec: Vec3): this;
     computeOffsetX(other: AABB, offsetX: number): number;
     computeOffsetY(other: AABB, offsetY: number): number;
     computeOffsetZ(other: AABB, offsetZ: number): number;

package/lib/calcs/aabb.js

@@ -31,15 +31,48 @@ class AABB {
     clone() {
         return new AABB(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
     }
+    minPoint() {
+        return new vec3_1.Vec3(this.minX, this.minY, this.minZ);
+    }
+    maxPoint() {
+        return new vec3_1.Vec3(this.maxX, this.maxY, this.maxZ);
+    }
+    bottomMiddlePoint() {
+        return new vec3_1.Vec3(lerp(0.5, this.minX, this.maxX), this.minY, lerp(0.5, this.minZ, this.maxZ));
+    }
+    heightAndWidths() {
+        return new vec3_1.Vec3(this.maxX - this.minX, this.maxY - this.minY, this.maxZ - this.minZ);
+    }
     toArray() {
         return [this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ];
     }
-    toMinAndMaxArrays() {
-        return [[this.minX, this.minY, this.minZ], [this.maxX, this.maxY, this.maxZ]];
+    minAndMaxArrays() {
+        return [
+            [this.minX, this.minY, this.minZ],
+            [this.maxX, this.maxY, this.maxZ],
+        ];
     }
     toVecs() {
         return [new vec3_1.Vec3(this.minX, this.minY, this.minZ), new vec3_1.Vec3(this.maxX, this.maxY, this.maxZ)];
     }
+    /**
+     * Compatible with Iterators from prismarine-world.
+     * Used like a block for prismarine-world.
+     * @returns {number[][]} single element long array of shapes.
+     */
+    toShapeFromMin() {
+        return [[0, 0, 0, this.maxX - this.minX, this.maxY - this.minY, this.maxZ - this.minZ]];
+    }
+    /**
+     * Compatible with Iterators from prismarine-world.
+     * Used with the entity's actual position for prismarine-world.
+     * @returns {number[][]} single element long array of shapes.
+     */
+    toShapeFromBottomMiddle() {
+        const wx = lerp(0.5, this.minX, this.maxX);
+        const wz = lerp(0.5, this.minX, this.maxX);
+        return [[-wx, 0, -wz, wx, this.maxY - this.minY, wz]];
+    }
     toVertices() {
         return [
             new vec3_1.Vec3(this.minX, this.minY, this.minZ),
@@ -103,6 +136,15 @@ class AABB {
         this.maxZ += z;
         return this;
     }
+    offsetVec(vec) {
+        this.minX += vec.x;
+        this.minY += vec.y;
+        this.minZ += vec.z;
+        this.maxX += vec.x;
+        this.maxY += vec.y;
+        this.maxZ += vec.z;
+        return this;
+    }
     computeOffsetX(other, offsetX) {
         if (other.maxY > this.minY && other.minY < this.maxY && other.maxZ > this.minZ && other.minZ < this.maxZ) {
             if (offsetX > 0.0 && other.maxX <= this.minX) {
@@ -167,7 +209,7 @@ class AABB {
     distanceFromRay(origin, direction, xz = false) {
         const ro = origin.toArray();
         const rd = direction.clone().normalize().toArray();
-        const aabb = this.toMinAndMaxArrays();
+        const aabb = this.minAndMaxArrays();
         const dims = ro.length; // will change later.
         const dif = xz ? 2 : 1;
         let lo = -Infinity;
@@ -262,7 +304,7 @@ class 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;
+        return (this.minX <= d4 && this.maxX >= d && this.minY <= d5 && this.maxY >= d2 && this.minZ <= d6 && this.maxZ >= d3);
     }
     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/calcs/intercept.d.ts

@@ -1,13 +1,13 @@
 import { Bot } from "mineflayer";
 import { Block } from "prismarine-block";
 import { Vec3 } from "vec3";
-declare type Iteration = {
+type Iteration = {
     x: number;
     y: number;
     z: number;
     face: number;
 };
-declare type BlockAndIterations = {
+type BlockAndIterations = {
     block: Block | null;
     iterations: Iteration[];
 };

package/lib/entityFunctions.d.ts

@@ -1,7 +1,5 @@
 import type { Bot } from "mineflayer";
 import type { Entity } from "prismarine-entity";
-import type { Vec3 } from "vec3";
-import { AABB } from "./calcs/aabb";
 export declare class EntityFunctions {
     bot: Bot;
     healthSlot: number;
@@ -38,22 +36,8 @@ export declare class EntityFunctions {
      * @returns
      */
     getHealthChange(packetMetadata: any, entity: Entity): number;
-    getDistanceToEntity(entity: Entity): number;
-    getEyeDistanceToEntity(entity: Entity): number;
-    getEyeDistanceBetweenEntities(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;
+    entityDistance(entity: Entity): number;
+    eyeDistanceToEntity(entity: Entity): number;
+    eyeDistanceBetweenEntities(first: Entity, second: Entity): number;
     private parseMetadata;
 }

package/lib/entityFunctions.js

@@ -1,23 +1,12 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityFunctions = void 0;
-const aabb_1 = require("./calcs/aabb");
+const static_1 = require("./static");
 class EntityFunctions {
     constructor(bot) {
         this.bot = bot;
         this.healthSlot = 7;
-        this.bot.on("spawn", () => __awaiter(this, void 0, void 0, function* () {
-            this.healthSlot = Number(this.bot.version.split(".")[1]) <= 16 ? 7 : 9;
-        }));
+        this.healthSlot = Number(this.bot.version.split(".")[1]) <= 16 ? 7 : 9;
     }
     /**
      * TODO: Version specific right now. Generalize. Unknown method.
@@ -70,32 +59,14 @@ class EntityFunctions {
         const newHealth = this.getHealthFromMetadata(this.parseMetadata(packetMetadata, entity.metadata));
         return newHealth - oldHealth;
     }
-    getDistanceToEntity(entity) {
+    entityDistance(entity) {
         return this.bot.entity.position.distanceTo(entity.position);
     }
-    getEyeDistanceToEntity(entity) {
-        return this.getEntityAABB(entity).distanceToVec(this.bot.entity.position.offset(0, 1.62, 0));
+    eyeDistanceToEntity(entity) {
+        return static_1.AABBUtils.getEntityAABB(entity).distanceToVec(this.bot.entity.position.offset(0, this.bot.entity.height, 0));
     }
-    getEyeDistanceBetweenEntities(first, second) {
-        return this.getEntityAABB(second).distanceToVec(first.position.offset(0, first.height, 0));
-    }
-    getEntityAABB(entity) {
-        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: entity.width });
-        }
-    }
-    getPlayerAABB(entity) {
-        return this.getEntityAABBRaw({ position: entity.position, height: 1.8, width: 0.6 });
-    }
-    getEntityAABBRaw(entity) {
-        const w = entity.width ? entity.width / 2 : entity.height / 2;
-        const { x, y, z } = entity.position;
-        return new aabb_1.AABB(-w, 0, -w, w, entity.height, w).offset(x, y, z);
+    eyeDistanceBetweenEntities(first, second) {
+        return static_1.AABBUtils.getEntityAABB(second).distanceToVec(first.position.offset(0, first.height, 0));
     }
     parseMetadata(packetMetadata, entityMetadata = {}) {
         if (packetMetadata !== undefined) {

package/lib/index.d.ts

@@ -1,10 +1,18 @@
 import type { Bot } from "mineflayer";
 import { UtilFunctions } from "./utilFunctions";
-import md from "minecraft-data";
 declare module "mineflayer" {
     interface Bot {
         util: UtilFunctions;
-        registry: md.IndexedData;
+    }
+}
+declare module "prismarine-entity" {
+    interface Entity {
+        attributes: {
+            [index: string]: {
+                value: number;
+                modifiers: any[];
+            };
+        };
     }
 }
 export default function inject(bot: Bot): void;

package/lib/movementFunctions.d.ts

@@ -1,9 +1,10 @@
 import type { Bot } from "mineflayer";
-import type { Vec3 } from "vec3";
+import { Vec3 } from "vec3";
+export declare function lerp(f: number, f2: number, f3: number): number;
 export declare class MovementFunctions {
     private bot;
     constructor(bot: Bot);
     forceLook(yaw: number, pitch: number, update?: boolean, onGround?: boolean): void;
     forceLookAt(pos: Vec3, update?: boolean, onGround?: boolean): void;
-    lazyTeleport(endPos: Vec3): void;
+    lazyTeleport(endPos: Vec3, steps?: number, update?: boolean): void;
 }

package/lib/movementFunctions.js

@@ -1,25 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MovementFunctions = void 0;
+exports.MovementFunctions = exports.lerp = void 0;
+const vec3_1 = require("vec3");
+const static_1 = require("./static");
+function lerp(f, f2, f3) {
+    return f2 + f * (f3 - f2);
+}
+exports.lerp = lerp;
+function* interpolate(start, end, steps = 1) {
+    for (let i = 0; i < steps; i++) {
+        yield new vec3_1.Vec3(lerp(i / steps, start.x, end.x), lerp(i / steps, start.y, end.y), lerp(i / steps, start.z, end.z));
+    }
+}
 class MovementFunctions {
     constructor(bot) {
         this.bot = bot;
     }
     forceLook(yaw, pitch, update = false, onGround) {
-        const notchianYawAndPitch = { yaw: this.bot.util.math.toNotchianYaw(yaw), pitch: this.bot.util.math.toNotchianPitch(pitch) };
+        const notchianYawAndPitch = { yaw: static_1.MathUtils.toNotchianYaw(yaw), pitch: static_1.MathUtils.toNotchianPitch(pitch) };
         this.bot._client.write("look", Object.assign(Object.assign({}, notchianYawAndPitch), { onGround: onGround !== null && onGround !== void 0 ? onGround : this.bot.entity.onGround }));
         if (update) {
             this.bot.look(yaw, pitch, true);
         }
     }
     forceLookAt(pos, update = false, onGround) {
-        const { yaw, pitch } = this.bot.util.math.pointToYawAndPitch(this.bot, pos);
-        const nyp = { yaw: this.bot.util.math.toNotchianYaw(yaw), pitch: this.bot.util.math.toNotchianPitch(pitch) };
+        const { yaw, pitch } = static_1.MathUtils.pointToYawAndPitch(this.bot, pos);
+        const nyp = { yaw: static_1.MathUtils.toNotchianYaw(yaw), pitch: static_1.MathUtils.toNotchianPitch(pitch) };
         this.bot._client.write("look", Object.assign(Object.assign({}, nyp), { onGround: onGround !== null && onGround !== void 0 ? onGround : this.bot.entity.onGround }));
         if (update) {
             this.bot.look(yaw, pitch, true);
         }
     }
-    lazyTeleport(endPos) { }
+    lazyTeleport(endPos, steps = 1, update = false) {
+        for (const pos of interpolate(this.bot.entity.position, endPos, steps)) {
+            this.bot._client.write("position", Object.assign(Object.assign({}, pos), { onGround: this.bot.entity.onGround }));
+        }
+        if (update)
+            this.bot.entity.position.set(endPos.x, endPos.y, endPos.z);
+    }
 }
 exports.MovementFunctions = MovementFunctions;

package/lib/predictiveFunctions.d.ts

@@ -2,7 +2,6 @@ import type { Bot } from "mineflayer";
 import type { Entity } from "prismarine-entity";
 import { Vec3 } from "vec3";
 import { Overwrites, PredictiveWorld } from "./worldRelated/predictiveWorld";
-export declare const ARMOR_THOUGHNESS_KEY = "generic.armorToughness";
 export declare class PredictiveFunctions {
     private bot;
     private damageMultiplier;

package/lib/predictiveFunctions.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PredictiveFunctions = exports.ARMOR_THOUGHNESS_KEY = void 0;
-const minecraft_data_1 = __importDefault(require("minecraft-data"));
+exports.PredictiveFunctions = void 0;
 const vec3_1 = require("vec3");
 const predictiveWorld_1 = require("./worldRelated/predictiveWorld");
+const static_1 = require("./static");
 const armorPieces = ["head", "torso", "legs", "feet"];
 // https://minecraft.fandom.com/wiki/Explosion
 // Use bot.world, there's no typing yet.
@@ -33,6 +30,32 @@ function calcExposure(playerPos, explosionPos, world) {
     }
     return exposed / sampled;
 }
+function calcExposureAABB(entityBB, explosionPos, world /* prismarine-world*/) {
+    const xWidth = entityBB.maxX - entityBB.minX;
+    const yWidth = entityBB.maxY - entityBB.minY;
+    const zWidth = entityBB.maxZ - entityBB.minZ;
+    const dx = 1 / (xWidth * 2 + 1);
+    const dy = 1 / (yWidth * 2 + 1);
+    const dz = 1 / (zWidth * 2 + 1);
+    const d3 = (1 - Math.floor(1 / dx) * dx) / 2;
+    const d4 = (1 - Math.floor(1 / dz) * dz) / 2;
+    let sampled = 0;
+    let exposed = 0;
+    const pos = new vec3_1.Vec3(0, 0, 0);
+    for (pos.y = entityBB.minY; pos.y <= entityBB.maxY; pos.y += yWidth * dy) {
+        for (pos.x = entityBB.minX + d3; pos.x <= entityBB.maxX; pos.x += xWidth * dx) {
+            for (pos.z = entityBB.minZ + d4; pos.z <= entityBB.maxZ; pos.z += zWidth * dz) {
+                const dir = pos.minus(explosionPos);
+                const range = dir.norm();
+                if (world.raycast(explosionPos, dir.normalize(), range) === null) {
+                    exposed++;
+                }
+                sampled++;
+            }
+        }
+    }
+    return exposed / sampled;
+}
 // https://minecraft.fandom.com/wiki/Armor#Damage_protection
 function getDamageAfterAbsorb(damages, armorValue, toughness) {
     const var3 = 2 + toughness / 4;
@@ -86,35 +109,23 @@ const DIFFICULTY_VALUES = {
     normal: 2,
     hard: 3,
 };
-exports.ARMOR_THOUGHNESS_KEY = "generic.armorToughness";
-const AIR_BLOCK = { type: 0 };
 class PredictiveFunctions {
     constructor(bot) {
         this.bot = bot;
-        this.resistanceIndex = "11";
-        const version = Number(bot.version.split(".")[1]);
-        if (version === 16) {
-            this.armorToughnessKey = "generic.armorToughness";
-            this.armorProtectionKey = "generic.armor";
-        }
-        else {
-            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;
+        this.resistanceIndex = 11;
+        const effects = bot.registry.effects;
         for (const effectId in effects) {
             const effect = effects[effectId];
-            if (effect.name.includes("resistance")) {
-                this.resistanceIndex = effectId;
+            if (effect.name.includes("esistance")) {
+                this.resistanceIndex = Number(effectId);
                 break;
             }
         }
+        this.damageMultiplier = bot.registry.version[">="]("1.9") ? 8 : 7; // for 1.12+ 8 for 1.8 TODO check when the change occur (likely 1.9)
+        this.armorToughnessKey = bot.registry.version[">="]("1.16")
+            ? "minecraft:generic.armor_toughness"
+            : "generic.armorToughness"; // was renamed in 1.16
+        this.armorProtectionKey = bot.registry.version[">="]("1.16") ? "minecraft:generic.armor" : "generic.armor"; // was renamed in 1.16
         this.world = new predictiveWorld_1.PredictiveWorld(bot);
     }
     //There's a mistyping in mineflayer. Effect[] is not accurate. You cannot map over it.
@@ -144,8 +155,7 @@ class PredictiveFunctions {
             const armor = getAttributeValue(this.bot.entity.attributes[this.armorProtectionKey]);
             const armorToughness = getAttributeValue(this.bot.entity.attributes[this.armorToughnessKey]);
             damages = getDamageAfterAbsorb(damages, armor, armorToughness);
-            const equipment = armorPieces.map((piece) => this.bot.inventory.slots[this.bot.getEquipmentDestSlot(piece)]);
-            damages = getDamageWithEnchantments(damages, equipment);
+            damages = getDamageWithEnchantments(damages, this.bot.entity.equipment);
             damages = this.getDamageWithEffects(damages, this.bot.entity.effects);
             damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
         }
@@ -156,7 +166,7 @@ class PredictiveFunctions {
         const radius = 2 * power;
         if (distance >= radius)
             return 0;
-        const exposure = calcExposure(targetEntity.position, sourcePos, this.world);
+        const exposure = calcExposureAABB(static_1.AABBUtils.getEntityAABB(targetEntity), sourcePos, this.world);
         const impact = (1 - distance / radius) * exposure;
         let damages = Math.floor((impact * impact + impact) * this.damageMultiplier * power + 1);
         // The following modifiers are constant for the input targetEntity and doesnt depend

package/lib/rayTracingFunctions.d.ts

@@ -1,15 +1,21 @@
 import { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
 import type { Entity } from "prismarine-entity";
 import { Vec3 } from "vec3";
+import AABB from "./calcs/aabb";
+import { BlockFace } from "./calcs/iterators";
+type RayAddtion = {
+    intersect: Vec3;
+    face: BlockFace;
+};
+export type EntityRaycastReturn = (Block | Entity) & RayAddtion;
 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;
+    entityRaytrace(startPos: Vec3, dir: Vec3, maxDistance?: number, matcher?: (e: Entity) => boolean): EntityRaycastReturn | null;
+    entityRaytraceRaw(startPos: Vec3, dir: Vec3, aabbMap: {
+        [id: string]: AABB;
+    }, maxDistance?: number, matcher?: (e: Entity) => boolean): EntityRaycastReturn | null;
     entityAtEntityCursor(entity: Entity, maxDistance?: number): Entity | null;
 }
+export {};

package/lib/rayTracingFunctions.js

@@ -3,28 +3,58 @@ 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);
-}
+const static_1 = require("./static");
 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);
+    entityRaytrace(startPos, dir, maxDistance = 3.5, matcher) {
+        const aabbMap = {};
+        Object.values(this.bot.entities)
+            .filter((e) => e.username !== this.bot.entity.username)
+            .forEach((e) => (aabbMap[e.id] = static_1.AABBUtils.getEntityAABB(e)));
+        return this.entityRaytraceRaw(startPos, dir, aabbMap, maxDistance, matcher);
     }
-    entityAtCursor(maxDistance = 3.5) {
-        return this.entityAtEntityCursor(this.bot.entity, maxDistance);
+    entityRaytraceRaw(startPos, dir, aabbMap, maxDistance = 3.5, matcher) {
+        var _a;
+        matcher || (matcher = (e) => true);
+        Object.entries(aabbMap).forEach(([id, bb]) => {
+            if (bb.distanceToVec(eyePos) > maxDistance)
+                delete aabbMap[id];
+        });
+        dir = dir.normalize();
+        let returnVal = this.bot.world.raycast(startPos, dir, maxDistance);
+        if (returnVal && Object.keys(aabbMap).length === 0)
+            return returnVal;
+        maxDistance = (_a = returnVal === null || returnVal === void 0 ? void 0 : returnVal.intersect.distanceTo(startPos)) !== null && _a !== void 0 ? _a : maxDistance;
+        const eyePos = this.bot.entity.position.offset(0, this.bot.entity.height, 0);
+        const iterator = new iterators_1.RaycastIterator(startPos, dir, maxDistance);
+        for (const id in aabbMap) {
+            const aabb = aabbMap[id];
+            const pt = aabb.bottomMiddlePoint();
+            const entity = this.bot.entities[id];
+            const intersect = iterator.intersect(aabb.toShapeFromBottomMiddle(), pt);
+            if (intersect) {
+                const entityDir = pt.minus(eyePos);
+                const sign = Math.sign(entityDir.dot(dir));
+                if (sign !== -1) {
+                    const dist = eyePos.distanceTo(intersect.pos);
+                    if (dist <= maxDistance) {
+                        maxDistance = dist;
+                        if (matcher(entity)) {
+                            returnVal = entity;
+                            returnVal.intersect = intersect.pos;
+                            returnVal.face = intersect.face;
+                        }
+                    }
+                }
+            }
+        }
+        return returnVal;
     }
     entityAtEntityCursor(entity, maxDistance = 3.5) {
         var _a;
-        const block = this.blockAtEntityCursor(entity, maxDistance);
+        const block = this.bot.blockAtCursor(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));
@@ -33,7 +63,7 @@ class RayTraceFunctions {
         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 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) {

package/lib/static/aabbUtil.d.ts

@@ -12,7 +12,10 @@ export declare namespace AABBUtils {
     }): AABB;
     function getPlayerAABB(entity: {
         position: Vec3;
+        height?: number;
+        width?: number;
     }): AABB;
+    function getPlayerAABBRaw(position: Vec3, height?: number): AABB;
     function getEntityAABBRaw(entity: {
         position: Vec3;
         height: number;

package/lib/static/aabbUtil.js

@@ -17,7 +17,7 @@ var AABBUtils;
     function getEntityAABB(entity) {
         switch (entity.type) {
             case "player":
-                return getPlayerAABB({ position: entity.position });
+                return getEntityAABBRaw({ position: entity.position, height: entity.height + 0.18, width: entity.width });
             case "mob":
             default: //TODO: Implement better AABBs. However, this may just be correct.
                 return getEntityAABBRaw({ position: entity.position, height: entity.height, width: entity.width });
@@ -25,9 +25,15 @@ var AABBUtils;
     }
     AABBUtils.getEntityAABB = getEntityAABB;
     function getPlayerAABB(entity) {
-        return getEntityAABBRaw({ position: entity.position, height: 1.8, width: 0.6 });
+        const w = entity.width ? entity.width / 2 : 0.6;
+        const { x, y, z } = entity.position;
+        return new aabb_1.AABB(-w, 0, -w, w, entity.height ? entity.height + 0.18 : 1.8, w).offset(x, y, z);
     }
     AABBUtils.getPlayerAABB = getPlayerAABB;
+    function getPlayerAABBRaw(position, height = 1.8) {
+        return new aabb_1.AABB(-0.6, 0, -0.6, 0.6, height, 0.6).offsetVec(position);
+    }
+    AABBUtils.getPlayerAABBRaw = getPlayerAABBRaw;
     function getEntityAABBRaw(entity) {
         const w = entity.width ? entity.width / 2 : entity.height / 2;
         const { x, y, z } = entity.position;

package/lib/static/mathUtil.js

@@ -59,7 +59,6 @@ var MathUtils;
         return yaw;
     }
     MathUtils.getYaw = getYaw;
-    //Scuffed.
     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,12 +1,9 @@
-/// <reference types="node" />
 import type { Bot } from "mineflayer";
 import { EntityFunctions } from "./entityFunctions";
 import { FilterFunctions } from "./filterFunctions";
 import { InventoryFunctions } from "./inventoryFunctions";
 import { MovementFunctions } from "./movementFunctions";
 import { PredictiveFunctions } from "./predictiveFunctions";
-import { MathFunctions } from "./mathUtil";
-import { WorldFunctions } from "./WorldFunctions";
 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.
@@ -30,9 +27,6 @@ export declare class UtilFunctions {
     entity: EntityFunctions;
     predict: PredictiveFunctions;
     filters: FilterFunctions;
-    math: MathFunctions;
-    world: WorldFunctions;
     raytrace: RayTraceFunctions;
     constructor(bot: Bot);
-    sleep: typeof import("timers/promises").setTimeout;
 }

package/lib/utilFunctions.js

@@ -5,10 +5,7 @@ const entityFunctions_1 = require("./entityFunctions");
 const filterFunctions_1 = require("./filterFunctions");
 const inventoryFunctions_1 = require("./inventoryFunctions");
 const movementFunctions_1 = require("./movementFunctions");
-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");
 /**
  * I don't believe I need any locks, as I'm only going to have one instance of this per bot.
@@ -28,15 +25,12 @@ const rayTracingFunctions_1 = require("./rayTracingFunctions");
 class UtilFunctions {
     constructor(bot) {
         this.bot = bot;
-        this.sleep = (0, util_1.promisify)(setTimeout);
         this.inv = new inventoryFunctions_1.InventoryFunctions(bot);
         this.move = new movementFunctions_1.MovementFunctions(bot);
         this.entity = new entityFunctions_1.EntityFunctions(bot);
         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();
     }
 }
 exports.UtilFunctions = UtilFunctions;

package/lib/worldRelated/predictiveWorld.d.ts

@@ -1,7 +1,8 @@
 import type { Bot } from "mineflayer";
 import type { Block } from "prismarine-block";
 import { Vec3 } from "vec3";
-export declare type Overwrites = {
+import AABB from "../calcs/aabb";
+export type Overwrites = {
     [coord: string]: Block | null;
 };
 /**
@@ -10,8 +11,8 @@ export declare type Overwrites = {
  * Currently, this class can predict explosion damages of crystals using a custom world.
  */
 export declare class PredictiveWorld {
-    bot: Bot;
     private blocks;
+    private originalWorld;
     constructor(bot: Bot);
     raycast(from: Vec3, direction: Vec3, range: number, matcher?: ((block: Block) => boolean) | null): Block | null;
     /**
@@ -25,7 +26,7 @@ export declare class PredictiveWorld {
     setBlocks(blocks: Overwrites): void;
     /**
      * @param {Vec3} pos
-     * @returns {Block} Block at position.
+     * @returns {Block | null} Block at position.
      */
     getBlock(pos: Vec3): Block | null;
     removeBlock(pos: Vec3, force: boolean): void;
@@ -36,6 +37,6 @@ export declare class PredictiveWorld {
      * @param block bot.block
      * @returns List of affected blocks that potentially protect the entity.
      */
-    getExplosionAffectedBlocks(playerPos: Vec3, explosionPos: Vec3): Overwrites;
-    loadExplosionAffectedBlocks(playerPos: Vec3, explosionPos: Vec3): void;
+    getExplosionAffectedBlocks(entityBB: AABB, explosionPos: Vec3): Overwrites;
+    loadProtectiveBlocks(playerPos: Vec3, explosionPos: Vec3): void;
 }

package/lib/worldRelated/predictiveWorld.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictiveWorld = void 0;
 const vec3_1 = require("vec3");
 const iterators_1 = require("../calcs/iterators");
+const static_1 = require("../static");
 /**
  * A class dedicated to predictive logic.
  *
@@ -10,8 +11,8 @@ const iterators_1 = require("../calcs/iterators");
  */
 class PredictiveWorld {
     constructor(bot) {
-        this.bot = bot;
         this.blocks = {};
+        this.originalWorld = bot.world;
     }
     raycast(from, direction, range, matcher = null) {
         const iter = new iterators_1.RaycastIterator(from, direction, range);
@@ -51,20 +52,21 @@ class PredictiveWorld {
     }
     /**
      * @param {Vec3} pos
-     * @returns {Block} Block at position.
+     * @returns {Block | null} Block at position.
      */
     getBlock(pos) {
+        var _a;
         const pblock = this.blocks[pos.toString()];
         if (pblock !== undefined && pblock !== null)
             return pblock;
-        return this.bot.blockAt(pos);
+        return (_a = this.originalWorld.getBlock(pos)) !== null && _a !== void 0 ? _a : null;
     }
     removeBlock(pos, force) {
         if (force) {
             delete this.blocks[pos.toString()];
         }
         else {
-            const realBlock = this.bot.blockAt(pos);
+            const realBlock = this.originalWorld.getBlock(pos);
             if (realBlock)
                 this.blocks[pos.toString()] = realBlock;
             else
@@ -80,17 +82,18 @@ class PredictiveWorld {
      * @param block bot.block
      * @returns List of affected blocks that potentially protect the entity.
      */
-    getExplosionAffectedBlocks(playerPos, explosionPos) {
+    getExplosionAffectedBlocks(entityBB, explosionPos) {
         let blocks = {};
-        const dx = 1 / (0.6 * 2 + 1);
-        const dy = 1 / (1.8 * 2 + 1);
-        const dz = 1 / (0.6 * 2 + 1);
+        const { x: xWidth, y: yWidth, z: zWidth } = entityBB.heightAndWidths();
+        const dx = 1 / (xWidth * 2 + 1);
+        const dy = 1 / (yWidth * 2 + 1);
+        const dz = 1 / (zWidth * 2 + 1);
         const d3 = (1 - Math.floor(1 / dx) * dx) / 2;
         const d4 = (1 - Math.floor(1 / dz) * dz) / 2;
         const pos = new vec3_1.Vec3(0, 0, 0);
-        for (pos.y = playerPos.y; pos.y <= playerPos.y + 1.8; pos.y += 1.8 * dy) {
-            for (pos.x = playerPos.x - 0.3 + d3; pos.x <= playerPos.x + 0.3; pos.x += 0.6 * dx) {
-                for (pos.z = playerPos.z - 0.3 + d4; pos.z <= playerPos.z + 0.3; pos.z += 0.6 * dz) {
+        for (pos.y = entityBB.minY; pos.y <= entityBB.maxY; pos.y += yWidth * dy) {
+            for (pos.x = entityBB.minX + d3; pos.x <= entityBB.maxX; pos.x += xWidth * dx) {
+                for (pos.z = entityBB.minZ + d4; pos.z <= entityBB.maxZ; pos.z += zWidth * dz) {
                     const dir = pos.minus(explosionPos);
                     const range = dir.norm();
                     const potentialBlock = this.raycast(explosionPos, dir.normalize(), range);
@@ -101,8 +104,8 @@ class PredictiveWorld {
         }
         return blocks;
     }
-    loadExplosionAffectedBlocks(playerPos, explosionPos) {
-        this.setBlocks(this.getExplosionAffectedBlocks(playerPos, explosionPos));
+    loadProtectiveBlocks(playerPos, explosionPos) {
+        this.setBlocks(this.getExplosionAffectedBlocks(static_1.AABBUtils.getPlayerAABBRaw(playerPos), explosionPos));
     }
 }
 exports.PredictiveWorld = PredictiveWorld;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nxg-org/mineflayer-util-plugin",
-    "version": "1.6.3",
+    "version": "1.7.0",
     "description": "mineflayer utils for NextGEN mineflayer plugins.",
     "keywords": [
         "mineflayer",
@@ -19,6 +19,7 @@
         "prepublish": "npm run build",
         "test": "ts-node examples/example.ts"
     },
+    "dependencies": {},
     "devDependencies": {
         "@types/node": "^17.0.4",
         "mineflayer": "^4.7.0",