@nxg-org/mineflayer-util-plugin 1.0.0

package/lib/WorldFunctions.d.ts

@@ -0,0 +1,10 @@
+import type { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
+import { AABB } from "./calcs/aabb";
+import type { Vec3 } from "vec3";
+export declare class WorldFunctions {
+    private bot;
+    constructor(bot: Bot);
+    getBlockAABB(block: Block, height?: number): AABB;
+    getBlockPosAABB(block: Vec3, height?: number): AABB;
+}

package/lib/WorldFunctions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorldFunctions = void 0;
+const aabb_1 = require("./calcs/aabb");
+class WorldFunctions {
+    constructor(bot) {
+        this.bot = bot;
+    }
+    getBlockAABB(block, height = 1) {
+        const { x, y, z } = block.position;
+        return new aabb_1.AABB(x, y, z, x + 1, y + height, z + 1);
+    }
+    getBlockPosAABB(block, height = 1) {
+        const { x, y, z } = block.floored();
+        return new aabb_1.AABB(x, y, z, x + 1, y + height, z + 1);
+    }
+}
+exports.WorldFunctions = WorldFunctions;

package/lib/calcs/aabb.d.ts

@@ -0,0 +1,36 @@
+import { Vec3 } from "vec3";
+export declare class AABB {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+    constructor(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number);
+    static fromVecs(min: Vec3, max: Vec3): AABB;
+    set(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
+    clone(): AABB;
+    toArray(): number[];
+    toMinAndMaxArrays(): {
+        0: number[];
+        1: number[];
+    };
+    toVecs(): {
+        0: Vec3;
+        1: Vec3;
+    };
+    floor(): void;
+    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;
+    computeOffsetX(other: AABB, offsetX: number): number;
+    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;
+    equals(other: AABB): boolean;
+    distanceTo(pos: Vec3, heightOffset?: number): number;
+}
+export default AABB;

package/lib/calcs/aabb.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AABB = void 0;
+const vec3_1 = require("vec3");
+class AABB {
+    constructor(x0, y0, z0, x1, y1, z1) {
+        this.minX = x0;
+        this.minY = y0;
+        this.minZ = z0;
+        this.maxX = x1;
+        this.maxY = y1;
+        this.maxZ = z1;
+    }
+    static fromVecs(min, max) {
+        return new AABB(min.x, min.y, min.z, max.x, max.y, max.z);
+    }
+    set(x0, y0, z0, x1, y1, z1) {
+        this.minX = x0;
+        this.minY = y0;
+        this.minZ = z0;
+        this.maxX = x1;
+        this.maxY = y1;
+        this.maxZ = z1;
+    }
+    clone() {
+        return new AABB(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
+    }
+    toArray() {
+        return [this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ];
+    }
+    toMinAndMaxArrays() {
+        return { 0: [this.minX, this.minY, this.minZ], 1: [this.maxX, this.maxY, this.maxZ] };
+    }
+    toVecs() {
+        return { 0: new vec3_1.Vec3(this.minX, this.minY, this.minZ), 1: new vec3_1.Vec3(this.maxX, this.maxY, this.maxZ) };
+    }
+    floor() {
+        this.minX = Math.floor(this.minX);
+        this.minY = Math.floor(this.minY);
+        this.minZ = Math.floor(this.minZ);
+        this.maxX = Math.floor(this.maxX);
+        this.maxY = Math.floor(this.maxY);
+        this.maxZ = Math.floor(this.maxZ);
+    }
+    extend(dx, dy, dz) {
+        if (dx < 0)
+            this.minX += dx;
+        else
+            this.maxX += dx;
+        if (dy < 0)
+            this.minY += dy;
+        else
+            this.maxY += dy;
+        if (dz < 0)
+            this.minZ += dz;
+        else
+            this.maxZ += dz;
+        return this;
+    }
+    contract(x, y, z) {
+        this.minX += x;
+        this.minY += y;
+        this.minZ += z;
+        this.maxX -= x;
+        this.maxY -= y;
+        this.maxZ -= z;
+        return this;
+    }
+    expand(x, y, z) {
+        this.minX -= x;
+        this.minY -= y;
+        this.minZ -= z;
+        this.maxX += x;
+        this.maxY += y;
+        this.maxZ += z;
+        return this;
+    }
+    offset(x, y, z) {
+        this.minX += x;
+        this.minY += y;
+        this.minZ += z;
+        this.maxX += x;
+        this.maxY += y;
+        this.maxZ += 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) {
+                offsetX = Math.min(this.minX - other.maxX, offsetX);
+            }
+            else if (offsetX < 0.0 && other.minX >= this.maxX) {
+                offsetX = Math.max(this.maxX - other.minX, offsetX);
+            }
+        }
+        return offsetX;
+    }
+    computeOffsetY(other, offsetY) {
+        if (other.maxX > this.minX && other.minX < this.maxX && other.maxZ > this.minZ && other.minZ < this.maxZ) {
+            if (offsetY > 0.0 && other.maxY <= this.minY) {
+                offsetY = Math.min(this.minY - other.maxY, offsetY);
+            }
+            else if (offsetY < 0.0 && other.minY >= this.maxY) {
+                offsetY = Math.max(this.maxY - other.minY, offsetY);
+            }
+        }
+        return offsetY;
+    }
+    computeOffsetZ(other, offsetZ) {
+        if (other.maxX > this.minX && other.minX < this.maxX && other.maxY > this.minY && other.minY < this.maxY) {
+            if (offsetZ > 0.0 && other.maxZ <= this.minZ) {
+                offsetZ = Math.min(this.minZ - other.maxZ, offsetZ);
+            }
+            else if (offsetZ < 0.0 && other.minZ >= this.maxZ) {
+                offsetZ = Math.max(this.maxZ - other.minZ, offsetZ);
+            }
+        }
+        return offsetZ;
+    }
+    intersects(other) {
+        return (this.minX < other.maxX &&
+            this.maxX > other.minX &&
+            this.minY < other.maxY &&
+            this.maxY > other.minY &&
+            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) {
+        const ro = origin.toArray();
+        const rd = direction.normalize().toArray();
+        const aabb = this.toMinAndMaxArrays();
+        const dims = ro.length; // will change later.
+        let lo = -Infinity;
+        let hi = +Infinity;
+        // let test = origin.clone()
+        for (let i = 0; i < dims; i++) {
+            let dimLo = (aabb[0][i] - ro[i]) / rd[i];
+            let dimHi = (aabb[1][i] - ro[i]) / rd[i];
+            if (dimLo > dimHi) {
+                let tmp = dimLo;
+                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)
+                lo = dimLo;
+            if (dimHi < hi)
+                hi = dimHi;
+        }
+        return lo > hi ? Infinity : lo;
+    }
+    equals(other) {
+        return (this.minX === other.minX &&
+            this.minY === other.minY &&
+            this.minZ === other.minZ &&
+            this.maxX === other.maxX &&
+            this.maxY === other.maxY &&
+            this.maxZ === other.maxZ);
+    }
+    distanceTo(pos, heightOffset = 0) {
+        const { x, y, z } = pos.offset(0, heightOffset, 0);
+        let dx = Math.max(this.minX - x, 0, x - this.maxX);
+        let dy = Math.max(this.minY - y, 0, y - this.maxY);
+        let dz = Math.max(this.minZ - z, 0, z - this.maxZ);
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+}
+exports.AABB = AABB;
+exports.default = AABB;

package/lib/commonSense.d.ts

@@ -0,0 +1,22 @@
+import type { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
+export declare class CommonSense {
+    bot: Bot;
+    autoRespond: boolean;
+    isFalling: boolean;
+    isOnFire: boolean;
+    checkForFalling: boolean;
+    checkForFire: boolean;
+    useOffHand: boolean;
+    requipLastItem: boolean;
+    puttingOutFire: boolean;
+    MLGing: boolean;
+    constructor(bot: Bot);
+    onMetadataFireCheck(packet: any): Promise<void>;
+    onStatusFireCheck(packet: any): Promise<void>;
+    putOutFire(): Promise<boolean>;
+    pickUpWater(nearbyBlock?: Block | null, maxDistance?: number, immediate?: boolean): Promise<void>;
+    isFallingCheckEasy(): Promise<void>;
+    private findBlockForWaterPlacement;
+    waterBucket(): Promise<boolean>;
+}

package/lib/commonSense.js

@@ -0,0 +1,220 @@
+"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.CommonSense = void 0;
+const vec3_1 = require("vec3");
+const util_1 = require("util");
+const sleep = (0, util_1.promisify)(setTimeout);
+class CommonSense {
+    constructor(bot) {
+        this.bot = bot;
+        this.autoRespond = false;
+        this.isFalling = false;
+        this.isOnFire = false;
+        this.checkForFalling = true;
+        this.checkForFire = true;
+        this.useOffHand = true;
+        this.requipLastItem = false;
+        this.puttingOutFire = false;
+        this.MLGing = false;
+        this.bot.on("physicsTick", this.isFallingCheckEasy.bind(this));
+        this.bot._client.on("entity_metadata", this.onMetadataFireCheck.bind(this));
+        this.bot._client.on("entity_status", this.onStatusFireCheck.bind(this));
+        // this.bot.on("physicsTick", this.onPhysicsTickFireCheck.bind(this));
+        //TODO: Move this to bot movement.
+    }
+    // async onPhysicsTickFireCheck() {
+    //     if ((this.bot.entity.metadata[0] as any) === 1) {
+    //         this.isOnFire = true;
+    //         while (!this.bot.entity.onGround) await sleep(0);
+    //         if (!this.puttingOutFire && this.autoRespond) this.putOutFire();
+    //     } else {
+    //         this.isOnFire = false
+    //     }
+    // }
+    onMetadataFireCheck(packet) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.checkForFire)
+                return;
+            if (!packet.entityId)
+                return;
+            const entity = this.bot.entities[packet.entityId];
+            if (!entity || entity !== this.bot.entity)
+                return;
+            // if ((entity.metadata[0] as any).value !== 1) {
+            const wantedKey = packet.metadata.findIndex((md) => md.key === 0);
+            if (wantedKey === -1)
+                return;
+            if (((_a = packet.metadata[wantedKey]) === null || _a === void 0 ? void 0 : _a.value) !== 1) {
+                this.isOnFire = false;
+                return;
+            }
+            // }
+            this.isOnFire = true;
+            while (!this.bot.entity.onGround)
+                yield this.bot.waitForTicks(1);
+            if (!this.puttingOutFire && this.autoRespond)
+                this.putOutFire();
+        });
+    }
+    onStatusFireCheck(packet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.checkForFire)
+                return;
+            if (!packet.entityId)
+                return;
+            const entity = this.bot.entities[packet.entityId];
+            if (!entity || entity !== this.bot.entity)
+                return;
+            if (!packet.entityStatus || packet.entityStatus !== 37) {
+                this.isOnFire = false;
+                return;
+            }
+            this.isOnFire = true;
+            while (!this.bot.entity.onGround)
+                yield sleep(0);
+            if (!this.puttingOutFire && this.autoRespond)
+                this.putOutFire();
+        });
+    }
+    putOutFire() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.puttingOutFire)
+                return true;
+            this.puttingOutFire = true;
+            const water = this.bot.util.inv.getAllItemsExceptCurrent("off-hand").find((item) => item === null || item === void 0 ? void 0 : item.name.includes("water_bucket"));
+            const holdingItem = (_a = this.bot.util.inv.getHandWithItem(this.useOffHand)) === null || _a === void 0 ? void 0 : _a.name.includes("water_bucket");
+            if (!water && !holdingItem) {
+                this.puttingOutFire = false;
+                return false;
+            }
+            else if (!holdingItem && water)
+                yield this.bot.util.inv.customEquip(water, "off-hand");
+            if ((_b = this.bot.util.inv.getHandWithItem(this.useOffHand)) === null || _b === void 0 ? void 0 : _b.name.includes("water_bucket")) {
+                const nearbyBlock = this.bot.findBlock({ matching: (block) => (block === null || block === void 0 ? void 0 : block.name) === "fire", maxDistance: 2 });
+                if (nearbyBlock) {
+                    yield this.bot.dig(nearbyBlock, true);
+                    yield this.bot.util.move.forceLookAt(nearbyBlock.position.offset(0, -1, 0));
+                }
+                else {
+                    yield this.bot.util.move.forceLook(this.bot.entity.yaw, -90);
+                }
+                // while (!this.bot.entity.isCollidedVertically) await this.bot.waitForTicks(1);
+                this.bot.activateItem(this.useOffHand);
+                yield this.pickUpWater(nearbyBlock);
+                this.puttingOutFire = false;
+                return true;
+            }
+            else {
+                this.puttingOutFire = false;
+                return false;
+            }
+        });
+    }
+    pickUpWater(nearbyBlock = null, maxDistance = 2, immediate = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!immediate)
+                yield this.bot.waitForTicks(3);
+            const block = this.bot.findBlock({
+                point: (_a = nearbyBlock === null || nearbyBlock === void 0 ? void 0 : nearbyBlock.position) !== null && _a !== void 0 ? _a : this.bot.entity.position,
+                matching: (block) => (block.type === 8 || block.type === 9) && block.metadata === 0,
+                //@ts-expect-error
+                useExtraInfo: (block) => {
+                    return this.bot.util.world.getBlockAABB(block).distanceTo(this.bot.entity.position, 1.62) < 4;
+                },
+                maxDistance: maxDistance,
+            });
+            if (block) {
+                this.bot.util.move.forceLookAt(block.position.offset(0.5, 0.5, 0.5), true);
+                this.bot.activateItem(this.useOffHand);
+            }
+            else {
+                console.log("didn't get block. fuck.");
+            }
+        });
+    }
+    isFallingCheckEasy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.checkForFalling)
+                return;
+            if (this.bot.entity.velocity.y >= -0.6) {
+                this.isFalling = false;
+                return;
+            }
+            this.isFalling = true;
+            if (!this.MLGing && this.autoRespond) {
+                yield this.waterBucket();
+            }
+        });
+    }
+    findBlockForWaterPlacement() {
+        const pos = this.bot.entity.position.offset(this.bot.entity.velocity.x, 0, this.bot.entity.velocity.z);
+        const aabb = this.bot.util.entity.getEntityAABB({
+            position: pos,
+            height: this.bot.entity.height,
+            width: 0.3,
+        });
+        const spacing = { x0: aabb.minX, z0: aabb.minZ, x1: aabb.maxX, z1: aabb.maxZ };
+        const floored = { x0: Math.floor(spacing.x0), z0: Math.floor(spacing.z0), x1: Math.floor(spacing.x1), z1: Math.floor(spacing.z1) };
+        let blocks = [];
+        const posY = this.bot.entity.position.clone().floored().y;
+        loop1: for (let i = floored.x0; i <= floored.x1; i++) {
+            loop2: for (let j = floored.z0; j <= floored.z1; j++) {
+                loop3: for (let k = posY; k > 0; k--) {
+                    const block = this.bot.blockAt(new vec3_1.Vec3(i, k, j));
+                    if (!!block && block.type !== 0) {
+                        blocks.push(block);
+                        break loop3;
+                    }
+                }
+            }
+        }
+        const maxY = Math.max(...blocks.map((b) => b.position.y));
+        blocks = blocks.filter((b) => b.position.y === maxY);
+        const block = blocks.sort((a, b) => this.bot.util.world.getBlockAABB(b).distanceTo(pos) - this.bot.util.world.getBlockAABB(a).distanceTo(pos))[0];
+        // console.log(block.position, this.bot.entity.position, this.bot.entity.position.distanceTo(block.position).toFixed(2));
+        return block;
+    }
+    waterBucket() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.MLGing)
+                return true;
+            this.MLGing = true;
+            const water = this.bot.util.inv.getAllItemsExceptCurrent("off-hand").find((item) => item === null || item === void 0 ? void 0 : item.name.includes("water_bucket"));
+            const holdingItem = (_a = this.bot.util.inv.getHandWithItem(true)) === null || _a === void 0 ? void 0 : _a.name.includes("water_bucket");
+            if (!water && !holdingItem) {
+                this.MLGing = false;
+                return false;
+            }
+            else if (!holdingItem && water)
+                yield this.bot.util.inv.customEquip(water, "off-hand");
+            for (let i = 0; i < 120; i++) {
+                const landingBlock = this.findBlockForWaterPlacement();
+                if (landingBlock) {
+                    yield this.bot.util.move.forceLookAt(landingBlock.position.offset(0.5, 0.5, 0.5), true);
+                }
+                if (this.bot.entity.position.y <= ((_b = landingBlock === null || landingBlock === void 0 ? void 0 : landingBlock.position.y) !== null && _b !== void 0 ? _b : 0) + 3) {
+                    this.bot.activateItem(this.useOffHand);
+                    break;
+                }
+                yield this.bot.waitForTicks(1);
+            }
+            yield this.pickUpWater(null, 2);
+            this.MLGing = false;
+            return true;
+        });
+    }
+}
+exports.CommonSense = CommonSense;

package/lib/customImplementations/inventory.d.ts

@@ -0,0 +1,10 @@
+import type { Bot, EquipmentDestination } from "mineflayer";
+import type { Item } from "prismarine-item";
+export declare class CustomInventoryFunctions {
+    private bot;
+    armorSlots: any;
+    constructor(bot: Bot);
+    equip(item: Item, destination: EquipmentDestination): Promise<void>;
+    setQuickBarSlot(slot: number): void;
+    getDestSlot(destination: EquipmentDestination): any;
+}

package/lib/customImplementations/inventory.js

@@ -0,0 +1,95 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomInventoryFunctions = void 0;
+const assert_1 = __importDefault(require("assert"));
+const util_1 = require("util");
+const sleep = (0, util_1.promisify)(setTimeout);
+const QUICK_BAR_COUNT = 9;
+const QUICK_BAR_START = 36;
+let nextQuickBarSlot = 0;
+//lazy. will fix this later.
+class CustomInventoryFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this.armorSlots = {
+            head: 5,
+            torso: 6,
+            legs: 7,
+            feet: 8,
+        };
+        if (!bot.supportFeature("doesntHaveOffHandSlot")) {
+            this.armorSlots["off-hand"] = 45;
+        }
+    }
+    equip(item, destination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (item == null || typeof item !== "object") {
+                throw new Error("Invalid item object in equip (item is null or typeof item is not object)");
+            }
+            if (!destination || destination === null) {
+                destination = "hand";
+            }
+            const sourceSlot = item.slot;
+            let destSlot = this.getDestSlot(destination);
+            if (sourceSlot === destSlot) {
+                // don't need to do anything
+                return;
+            }
+            if (destination !== "hand") {
+                yield this.bot.moveSlotItem(sourceSlot, destSlot);
+                return;
+            }
+            if (destSlot >= QUICK_BAR_START &&
+                destSlot < QUICK_BAR_START + QUICK_BAR_COUNT &&
+                sourceSlot >= QUICK_BAR_START &&
+                sourceSlot < QUICK_BAR_START + QUICK_BAR_COUNT) {
+                // all we have to do is change the quick bar selection
+                this.bot.setQuickBarSlot(sourceSlot - QUICK_BAR_START);
+                return;
+            }
+            // find an empty slot on the quick bar to put the source item in
+            destSlot = this.bot.inventory.firstEmptySlotRange(QUICK_BAR_START, QUICK_BAR_START + QUICK_BAR_COUNT);
+            if (destSlot == null) {
+                // LRU cache for the quick bar items
+                destSlot = QUICK_BAR_START + nextQuickBarSlot;
+                nextQuickBarSlot = (nextQuickBarSlot + 1) % QUICK_BAR_COUNT;
+            }
+            this.setQuickBarSlot(destSlot - QUICK_BAR_START);
+            yield this.bot.moveSlotItem(sourceSlot, destSlot);
+        });
+    }
+    setQuickBarSlot(slot) {
+        assert_1.default.ok(slot >= 0);
+        assert_1.default.ok(slot < 9);
+        if (this.bot.quickBarSlot === slot)
+            return;
+        this.bot.quickBarSlot = slot;
+        this.bot._client.write("held_item_slot", {
+            slotId: slot,
+        });
+        this.bot.updateHeldItem();
+    }
+    getDestSlot(destination) {
+        if (destination === "hand") {
+            return QUICK_BAR_START + this.bot.quickBarSlot;
+        }
+        else {
+            const destSlot = this.armorSlots[destination];
+            assert_1.default.ok(destSlot != null, `invalid destination: ${destination}`);
+            return destSlot;
+        }
+    }
+}
+exports.CustomInventoryFunctions = CustomInventoryFunctions;

package/lib/entityFunctions.d.ts

@@ -0,0 +1,36 @@
+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;
+    constructor(bot: Bot);
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     *
+     * Checks if main hand is activated.
+     * @returns boolean
+     */
+    isMainHandActive(entity?: Entity): boolean;
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     *
+     * Checks if offhand is activated.
+     * @returns boolean
+     */
+    isOffHandActive(entity?: Entity): boolean;
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     * @param metadata metadata from Prismarine-Entity Entity.
+     * @returns
+     */
+    getHealth(entity?: Entity): number;
+    getDistanceToEntity(entity: Entity): number;
+    getDistanceBetweenEntities(first: Entity, second: Entity): number;
+    getEntityAABB(entity: {
+        position: Vec3;
+        height: number;
+        width?: number;
+    }): AABB;
+}