@nxg-org/mineflayer-util-plugin 1.0.1 → 1.0.2

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;
+}

package/lib/entityFunctions.js

@@ -0,0 +1,78 @@
+"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");
+class EntityFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this.healthSlot = 7;
+        this.bot.on("spawn", () => __awaiter(this, void 0, void 0, function* () {
+            // await this.bot.util.sleep(1000)
+            // const slot = this.bot.entity.metadata.slice(5).findIndex((data) => Number(data) === 20);
+            // if (slot > 0) {
+            //     this.healthSlot = slot + 5;
+            // }
+            this.healthSlot = Number(this.bot.version.split(".")[1]) <= 16 ? 7 : 9;
+        }));
+    }
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     *
+     * Checks if main hand is activated.
+     * @returns boolean
+     */
+    isMainHandActive(entity) {
+        return (entity !== null && entity !== void 0 ? entity : this.bot.entity).metadata[6] === 1; //as any & (1 | 0)) === (1 | 0);
+    }
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     *
+     * Checks if offhand is activated.
+     * @returns boolean
+     */
+    isOffHandActive(entity) {
+        return (entity !== null && entity !== void 0 ? entity : this.bot.entity).metadata[6] === 1; //& (1 | 2)) === (1 | 2);
+    }
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     * @param metadata metadata from Prismarine-Entity Entity.
+     * @returns
+     */
+    getHealth(entity) {
+        var _a, _b;
+        entity = entity !== null && entity !== void 0 ? entity : this.bot.entity;
+        let metadata = entity.metadata;
+        //console.log(entity.metadata, this.healthSlot, this.bot.entity.health)
+        let healthSlot = this.healthSlot; //metadata[this.healthSlot] ? this.healthSlot : metadata.findIndex((met) => Number(met) > 1 && Number(met) <= 20);
+        // return Number(metadata[healthSlot]) + (Number(metadata[healthSlot + 4]) ?? 0);
+        let health = Number(metadata[healthSlot]);
+        if (!health || health === 0)
+            health = entity === this.bot.entity ? (_a = this.bot.entity.health) !== null && _a !== void 0 ? _a : 0 : 0;
+        if (health === 0)
+            console.log(this.healthSlot, entity.metadata);
+        // console.log(health + (Number(metadata[this.healthSlot + 4]) ?? 0))
+        return health + ((_b = Number(metadata[this.healthSlot + 4])) !== null && _b !== void 0 ? _b : 0);
+    }
+    getDistanceToEntity(entity) {
+        return this.getDistanceBetweenEntities(this.bot.entity, entity);
+    }
+    getDistanceBetweenEntities(first, second) {
+        return first.position.distanceTo(second.position);
+    }
+    getEntityAABB(entity) {
+        var _a;
+        const w = (_a = entity.width) !== null && _a !== void 0 ? _a : 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);
+    }
+}
+exports.EntityFunctions = EntityFunctions;

package/lib/filterFunctions.d.ts

@@ -0,0 +1,23 @@
+import type { Entity } from "prismarine-entity";
+import type { Bot } from "mineflayer";
+import type { Vec3 } from "vec3";
+/**
+ * TODO: Inherit other bot names. May need to communciate to a server for this one. Or perhaps reference this once?
+ */
+export declare class FilterFunctions {
+    private bot;
+    specificNames: string[];
+    botNames: string[];
+    constructor(bot: Bot);
+    addBotName(name: string): void;
+    getNearestEntity(func: (entity: Entity, ...args: any[]) => boolean, ...args: any[]): Entity | null;
+    static getNearestEntity(bot: Bot, func: (entity: Entity, ...args: any[]) => boolean, ...args: any[]): Entity | null;
+    allButOtherBotsFilter(): Entity | null;
+    static allButOtherBotsFilter(bot: Bot, ...names: string[]): Entity | null;
+    specificNamesFilter(): Entity | null;
+    static specificNamesFilter(bot: Bot, ...names: string[]): Entity | null;
+    nearestCrystalFilter(): Entity | null;
+    static nearestCrystalFilter(bot: Bot): Entity | null;
+    entityAtPosition(position: Vec3): Entity | null;
+    static entityAtPosition(bot: Bot, position: Vec3): void;
+}

package/lib/filterFunctions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterFunctions = void 0;
+/**
+ * TODO: Inherit other bot names. May need to communciate to a server for this one. Or perhaps reference this once?
+ */
+class FilterFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this.specificNames = [];
+        this.botNames = [];
+    }
+    addBotName(name) {
+        this.botNames.push(name);
+    }
+    getNearestEntity(func, ...args) {
+        return this.bot.nearestEntity((entity) => func(entity, ...args));
+    }
+    static getNearestEntity(bot, func, ...args) {
+        return bot.nearestEntity((entity) => func(entity, ...args));
+    }
+    allButOtherBotsFilter() {
+        return this.getNearestEntity((e) => { var _a, _b, _c; return e.type === "player" && ((_c = !((_a = this.botNames) === null || _a === void 0 ? void 0 : _a.includes((_b = e.username) !== null && _b !== void 0 ? _b : ""))) !== null && _c !== void 0 ? _c : true); });
+    }
+    static allButOtherBotsFilter(bot, ...names) {
+        return FilterFunctions.getNearestEntity(bot, (e) => { var _a; return e.type === "player" && !names.includes((_a = e.username) !== null && _a !== void 0 ? _a : ""); });
+    }
+    specificNamesFilter() {
+        return this.getNearestEntity((e) => { var _a, _b, _c; return e.type === "player" && ((_c = (_a = this.specificNames) === null || _a === void 0 ? void 0 : _a.includes((_b = e.username) !== null && _b !== void 0 ? _b : "")) !== null && _c !== void 0 ? _c : true); });
+    }
+    static specificNamesFilter(bot, ...names) {
+        return FilterFunctions.getNearestEntity(bot, (e) => { var _a; return e.type === "player" && names.includes((_a = e.username) !== null && _a !== void 0 ? _a : ""); });
+    }
+    nearestCrystalFilter() {
+        return this.getNearestEntity((e) => e.name === "ender_crystal");
+    }
+    static nearestCrystalFilter(bot) {
+        return FilterFunctions.getNearestEntity(bot, (e) => e.name === "ender_crystal");
+    }
+    entityAtPosition(position) {
+        return this.getNearestEntity((entity) => entity.position.offset(-0.5, -1, -0.5).equals(position));
+    }
+    static entityAtPosition(bot, position) { }
+}
+exports.FilterFunctions = FilterFunctions;

package/{src/index.ts → lib/index.d.ts}

@@ -1,13 +1,10 @@
 import type { Bot } from "mineflayer";
 import { UtilFunctions } from "./utilFunctions";
-import { PredictiveWorld } from "./worldRelated/predictiveWorld";
-
 declare module "mineflayer" {
     type PrioGroups = "inventory" | "movement";
     interface Bot {
         util: UtilFunctions;
     }
-
     interface BotEvents {
         startedEquippingMainHand: () => void;
         startedEquippingOffHand: () => void;
@@ -17,16 +14,16 @@ declare module "mineflayer" {
         stoppedEquippingOtherSlot: () => void;
     }
 }
-
 declare module "prismarine-entity" {
     interface Entity {
-        attributes: { [index: string]: { value: number; modifiers: any[] } };
+        attributes: {
+            [index: string]: {
+                value: number;
+                modifiers: any[];
+            };
+        };
     }
 }
-
-export default function inject(bot: Bot) {
-    bot.util = new UtilFunctions(bot);
-}
-
+export default function inject(bot: Bot): void;
 export { CommonSense } from "./commonSense";
 export { AABB } from "./calcs/aabb";

package/lib/inventoryFunctions.d.ts

@@ -0,0 +1,45 @@
+import { Bot, EquipmentDestination } from "mineflayer";
+import { Item } from "prismarine-item";
+import { BuiltInPriorityOptions } from "./utilFunctions";
+/**
+ * Error codes:
+ *
+ * 0 = completed successfully.
+ *
+ * 1 = Item is already equipped.
+ *
+ * 2 = Item could not be found.
+ *
+ * 3 = We are currently equipping an item.
+ */
+export declare class InventoryFunctions {
+    bot: Bot;
+    private _equippingMainHand;
+    private _equippingOffHand;
+    private _equippingOtherSlot;
+    usingMainHand: boolean;
+    usingOffHand: boolean;
+    constructor(bot: Bot);
+    set equippingOtherSlot(value: boolean);
+    get equippingOtherSlot(): boolean;
+    set equippingMainHand(value: boolean);
+    get equippingMainHand(): boolean;
+    set equippingOffHand(value: boolean);
+    get equippingOffHand(): boolean;
+    getAllItems(): Item[];
+    getAllItemsExceptCurrent(current: EquipmentDestination): Item[];
+    getHandWithItem(offhand?: boolean): Item | null;
+    getHand(offhand?: boolean): "hand" | "off-hand";
+    findItemByID(itemId: number, metadata?: number): Item | null;
+    findItem(name: string, metadata?: number): Item | null;
+    has(name: string, metadata?: number): boolean;
+    equipItemRaw(item: Item, dest: EquipmentDestination): Promise<boolean>;
+    equipItem(name: string, dest: EquipmentDestination, options: BuiltInPriorityOptions): Promise<number>;
+    equipMainHand(name: string, options?: BuiltInPriorityOptions): Promise<number>;
+    equipOffHand(name: string, options?: BuiltInPriorityOptions): Promise<number>;
+    equipSlot(name: string, destination: EquipmentDestination, options?: BuiltInPriorityOptions): Promise<number>;
+    equipMainHandNoWait(name: string, options: BuiltInPriorityOptions): Promise<number>;
+    equipOffHandNoWait(name: string, options: BuiltInPriorityOptions): Promise<number>;
+    equipSlotNoWait(name: string, dest: EquipmentDestination, options: BuiltInPriorityOptions): Promise<number>;
+    customEquip(item: Item, destination: EquipmentDestination, retries?: number): Promise<boolean>;
+}

package/lib/inventoryFunctions.js

@@ -0,0 +1,208 @@
+"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.InventoryFunctions = void 0;
+const util_1 = require("util");
+const sleep = (0, util_1.promisify)(setTimeout);
+/**
+ * Error codes:
+ *
+ * 0 = completed successfully.
+ *
+ * 1 = Item is already equipped.
+ *
+ * 2 = Item could not be found.
+ *
+ * 3 = We are currently equipping an item.
+ */
+class InventoryFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this._equippingMainHand = false;
+        this._equippingOffHand = false;
+        this._equippingOtherSlot = false;
+        this.usingMainHand = false;
+        this.usingOffHand = false;
+    }
+    set equippingOtherSlot(value) {
+        if (this._equippingOtherSlot === value)
+            return;
+        if (value)
+            this.bot.emit("startedEquippingOtherSlot");
+        else
+            this.bot.emit("stoppedEquippingOtherSlot");
+        this._equippingOtherSlot = value;
+    }
+    get equippingOtherSlot() {
+        return this._equippingOtherSlot;
+    }
+    set equippingMainHand(value) {
+        if (this._equippingMainHand === value)
+            return;
+        if (value)
+            this.bot.emit("startedEquippingMainHand");
+        else
+            this.bot.emit("stoppedEquippingMainHand");
+        this._equippingMainHand = value;
+    }
+    get equippingMainHand() {
+        return this._equippingMainHand;
+    }
+    set equippingOffHand(value) {
+        if (this._equippingOffHand === value)
+            return;
+        if (value)
+            this.bot.emit("startedEquippingOffHand");
+        else
+            this.bot.emit("stoppedEquippingOffHand");
+        this._equippingOffHand = value;
+    }
+    get equippingOffHand() {
+        return this._equippingOffHand;
+    }
+    getAllItems() {
+        return [
+            ...this.bot.inventory.items(),
+            ...["hand", "head", "torso", "legs", "feet", "off-hand"].map((name) => this.bot.inventory.slots[this.bot.getEquipmentDestSlot(name)]),
+        ].filter((e) => !!e);
+    }
+    getAllItemsExceptCurrent(current) {
+        return [
+            ...this.bot.inventory.items(),
+            ...["hand", "head", "torso", "legs", "feet", "off-hand"]
+                .filter((name) => name !== current)
+                .map((name) => this.bot.inventory.slots[this.bot.getEquipmentDestSlot(name)]),
+        ].filter((e) => !!e);
+    }
+    getHandWithItem(offhand) {
+        return this.bot.inventory.slots[this.bot.getEquipmentDestSlot(this.getHand(offhand))];
+    }
+    getHand(offhand = false) {
+        return offhand ? "off-hand" : "hand";
+    }
+    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;
+    }
+    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;
+    }
+    //alias.
+    has(name, metadata) {
+        return !!this.findItem(name, metadata);
+    }
+    equipItemRaw(item, dest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.bot.inventory.slots[this.bot.getEquipmentDestSlot(dest)] === item)
+                return true;
+            yield this.bot.equip(item, dest);
+            return false;
+        });
+    }
+    equipItem(name, dest, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.bot.inventory.slots[this.bot.getEquipmentDestSlot(dest)]) === null || _a === void 0 ? void 0 : _a.name.includes(name))
+                return 1;
+            const item = this.getAllItemsExceptCurrent(dest).find((item) => item === null || item === void 0 ? void 0 : item.name.includes(name));
+            if (!!item) {
+                yield this.bot.util.builtInsPriority(options, this.bot.equip, item, dest);
+                return 0;
+            }
+            return 2;
+        });
+    }
+    equipMainHand(name, options = { group: "inventory", priority: 1 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this._equippingMainHand) {
+                yield sleep(0);
+            }
+            return yield this.equipMainHandNoWait(name, options);
+        });
+    }
+    equipOffHand(name, options = { group: "inventory", priority: 1 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this._equippingOffHand) {
+                yield sleep(0);
+            }
+            return yield this.equipOffHandNoWait(name, options);
+        });
+    }
+    equipSlot(name, destination, options = { group: "inventory", priority: 1 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (this._equippingOtherSlot) {
+                yield sleep(0);
+            }
+            return yield this.equipSlotNoWait(name, destination, options);
+        });
+    }
+    equipMainHandNoWait(name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._equippingMainHand)
+                return 3;
+            this._equippingMainHand = true;
+            const result = yield this.equipItem(name, "hand", options);
+            this._equippingMainHand = false;
+            return result;
+        });
+    }
+    equipOffHandNoWait(name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._equippingOffHand)
+                return 3;
+            this.equippingOffHand = true;
+            const result = yield this.equipItem(name, "off-hand", options);
+            this.equippingOffHand = false;
+            return result;
+        });
+    }
+    equipSlotNoWait(name, dest, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._equippingOtherSlot)
+                return 3;
+            this.equippingOtherSlot = true;
+            const result = yield this.equipItem(name, dest, options);
+            this.equippingOtherSlot = false;
+            return result;
+        });
+    }
+    customEquip(item, destination, retries = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < retries; i++) {
+                try {
+                    yield this.bot.equip(item, destination);
+                    return true;
+                }
+                catch (error) {
+                    if (this.bot.inventory.selectedItem) {
+                        const slot = this.bot.inventory.firstEmptyInventorySlot(false) || -999;
+                        try {
+                            yield this.bot.clickWindow(slot, 0, 0);
+                        }
+                        catch (error) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            return false;
+        });
+    }
+}
+exports.InventoryFunctions = InventoryFunctions;

package/lib/mathUtil.d.ts

@@ -0,0 +1,23 @@
+import { Bot } from "mineflayer";
+import { Vec3 } from "vec3";
+export declare class MathFunctions {
+    constructor();
+    toNotchianYaw: (yaw: number) => number;
+    toNotchianPitch: (pitch: number) => number;
+    fromNotchianYawByte: (yaw: number) => number;
+    fromNotchianPitchByte: (pitch: number) => number;
+    euclideanMod(numerator: number, denominator: number): number;
+    toRadians(degrees: number): number;
+    toDegrees(radians: number): number;
+    fromNotchianYaw(yaw: number): number;
+    fromNotchianPitch(pitch: number): number;
+    fromNotchVelocity(vel: Vec3): Vec3;
+    pointToYawAndPitch(bot: Bot, point: Vec3): {
+        yaw: number;
+        pitch: number;
+    };
+    dirToYawAndPitch(dir: Vec3): {
+        yaw: number;
+        pitch: number;
+    };
+}

package/{src/mathUtil.ts → lib/mathUtil.js}

@@ -1,6 +1,7 @@
-import { Bot } from "mineflayer";
-import { Vec3 } from "vec3";
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathFunctions = void 0;
+const vec3_1 = require("vec3");
 const PI = Math.PI;
 const PI_2 = Math.PI * 2;
 const TO_RAD = PI / 180;
@@ -8,49 +9,41 @@ 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;
-
-export class MathFunctions {
-    constructor() {}
-
-    toNotchianYaw = (yaw: number) => this.toDegrees(PI - yaw);
-    toNotchianPitch = (pitch: number) => this.toDegrees(-pitch);
-    fromNotchianYawByte = (yaw: number) => this.fromNotchianYaw(yaw * FROM_NOTCH_BYTE);
-    fromNotchianPitchByte = (pitch: number) => this.fromNotchianPitch(pitch * FROM_NOTCH_BYTE);
-
-    euclideanMod(numerator: number, denominator: number) {
+class MathFunctions {
+    constructor() {
+        this.toNotchianYaw = (yaw) => this.toDegrees(PI - yaw);
+        this.toNotchianPitch = (pitch) => this.toDegrees(-pitch);
+        this.fromNotchianYawByte = (yaw) => this.fromNotchianYaw(yaw * FROM_NOTCH_BYTE);
+        this.fromNotchianPitchByte = (pitch) => this.fromNotchianPitch(pitch * FROM_NOTCH_BYTE);
+    }
+    euclideanMod(numerator, denominator) {
         const result = numerator % denominator;
         return result < 0 ? result + denominator : result;
     }
-
-    toRadians(degrees: number) {
+    toRadians(degrees) {
         return TO_RAD * degrees;
     }
-
-    toDegrees(radians: number) {
+    toDegrees(radians) {
         return TO_DEG * radians;
     }
-
-    fromNotchianYaw(yaw: number) {
+    fromNotchianYaw(yaw) {
         return this.euclideanMod(PI - this.toRadians(yaw), PI_2);
     }
-
-    fromNotchianPitch(pitch: number) {
+    fromNotchianPitch(pitch) {
         return this.euclideanMod(this.toRadians(-pitch) + PI, PI_2) - PI;
     }
-
-    fromNotchVelocity(vel: Vec3) {
-        return new Vec3(vel.x * FROM_NOTCH_VEL, vel.y * FROM_NOTCH_VEL, vel.z * FROM_NOTCH_VEL);
+    fromNotchVelocity(vel) {
+        return new vec3_1.Vec3(vel.x * FROM_NOTCH_VEL, vel.y * FROM_NOTCH_VEL, vel.z * FROM_NOTCH_VEL);
     }
-
-    pointToYawAndPitch(bot: Bot, point: Vec3) {
+    pointToYawAndPitch(bot, point) {
         const delta = point.minus(bot.entity.position.offset(0, bot.entity.height, 0));
         return this.dirToYawAndPitch(delta);
     }
-
-    dirToYawAndPitch(dir: Vec3) {
+    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 };
     }
 }
+exports.MathFunctions = MathFunctions;

package/lib/movementFunctions.d.ts

@@ -0,0 +1,43 @@
+import type { Bot } from "mineflayer";
+import type { Entity } from "prismarine-entity";
+import type { Vec3 } from "vec3";
+import { goals } from "mineflayer-pathfinder";
+export declare class MovementFunctions {
+    bot: Bot;
+    goalArray: goals.GoalCompositeAll;
+    lastYaw: number;
+    lastPitch: number;
+    constructor(bot: Bot);
+    /**
+     * Fuckin' mineflayer-pathfinder still doesn't have typings.
+     * Pain in my goddamn ass.
+     * @returns have the goal changed
+     */
+    addGoal(goal: any): boolean;
+    /**
+     * Sets current goal and clears all others.
+     * @param goal any type of mineflayer-pathfinder goal.
+     * @returns have the goal changed
+     */
+    setOnlyGoal(goal: any, dynamic?: boolean): boolean;
+    /**
+     * Reset all goals inside the goal array to none.
+     * @returns have the goals changed
+     */
+    stop(): boolean;
+    /**
+     * Retreat from current entity.
+     * @param entity Prismarine-Entity Entity
+     * @returns have the goals changed.
+     */
+    retreatFromEntity(entity: Entity, distance: number, dynamic?: boolean): boolean;
+    /**
+     * Follow entity with a specific range. Will not approach past a certain distance either.
+     * @param entity Prismarine-Entity Entity
+     * @returns have the goals changed
+     */
+    followEntityWithRespectRange(entity: Entity, followDistance: number, invertDistance?: number): boolean;
+    forceLook(yaw: number, pitch: number, update?: boolean): void;
+    forceLookAt(pos: Vec3, update?: boolean, trueForce?: boolean): void;
+    lazyTeleport(endPos: Vec3): void;
+}