@nxg-org/mineflayer-util-plugin 1.0.0

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/lib/index.d.ts

@@ -0,0 +1,27 @@
+import type { Bot } from "mineflayer";
+import { UtilFunctions } from "./utilFunctions";
+declare module "mineflayer" {
+    type PrioGroups = "inventory" | "movement";
+    interface Bot {
+        util: UtilFunctions;
+    }
+    interface BotEvents {
+        startedEquippingMainHand: () => void;
+        startedEquippingOffHand: () => void;
+        stoppedEquippingMainHand: () => void;
+        stoppedEquippingOffHand: () => void;
+        startedEquippingOtherSlot: () => void;
+        stoppedEquippingOtherSlot: () => void;
+    }
+}
+declare module "prismarine-entity" {
+    interface Entity {
+        attributes: {
+            [index: string]: {
+                value: number;
+                modifiers: any[];
+            };
+        };
+    }
+}
+export default function inject(bot: Bot): void;

package/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utilFunctions_1 = require("./utilFunctions");
+function inject(bot) {
+    bot.util = new utilFunctions_1.UtilFunctions(bot);
+}
+exports.default = inject;

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/lib/mathUtil.js

@@ -0,0 +1,49 @@
+"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;
+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;
+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) {
+        return TO_RAD * degrees;
+    }
+    toDegrees(radians) {
+        return TO_DEG * radians;
+    }
+    fromNotchianYaw(yaw) {
+        return this.euclideanMod(PI - this.toRadians(yaw), PI_2);
+    }
+    fromNotchianPitch(pitch) {
+        return this.euclideanMod(this.toRadians(-pitch) + PI, PI_2) - PI;
+    }
+    fromNotchVelocity(vel) {
+        return new vec3_1.Vec3(vel.x * FROM_NOTCH_VEL, vel.y * FROM_NOTCH_VEL, vel.z * FROM_NOTCH_VEL);
+    }
+    pointToYawAndPitch(bot, point) {
+        const delta = point.minus(bot.entity.position.offset(0, bot.entity.height, 0));
+        return this.dirToYawAndPitch(delta);
+    }
+    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;
+}

package/lib/movementFunctions.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MovementFunctions = void 0;
+const mineflayer_pathfinder_1 = require("mineflayer-pathfinder");
+const { GoalCompositeAll, GoalInvert, GoalFollow } = mineflayer_pathfinder_1.goals;
+class MovementFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this.goalArray = new GoalCompositeAll();
+        this.lastYaw = 0;
+        this.lastPitch = 0;
+    }
+    /**
+     * Fuckin' mineflayer-pathfinder still doesn't have typings.
+     * Pain in my goddamn ass.
+     * @returns have the goal changed
+     */
+    addGoal(goal) {
+        if (this.goalArray.goals.find((inGoal) => inGoal === goal))
+            return false;
+        this.goalArray.push(goal);
+        return true;
+    }
+    /**
+     * Sets current goal and clears all others.
+     * @param goal any type of mineflayer-pathfinder goal.
+     * @returns have the goal changed
+     */
+    setOnlyGoal(goal, dynamic = false) {
+        const goalArr = [goal];
+        if (this.goalArray.goals === goalArr)
+            return false;
+        this.goalArray.goals = goalArr;
+        this.bot.pathfinder.setGoal(this.goalArray, dynamic);
+        return true;
+    }
+    /**
+     * Reset all goals inside the goal array to none.
+     * @returns have the goals changed
+     */
+    stop() {
+        if (this.goalArray.goals.length === 0)
+            return false;
+        this.goalArray.goals = [];
+        this.bot.pathfinder.setGoal(null);
+        return true;
+    }
+    /**
+     * Retreat from current entity.
+     * @param entity Prismarine-Entity Entity
+     * @returns have the goals changed.
+     */
+    retreatFromEntity(entity, distance, dynamic = true) {
+        const oldGoals = this.goalArray.goals.length;
+        this.goalArray.goals = this.goalArray.goals.filter((goal) => { var _a, _b, _c; return ((_b = (_a = goal.goal) === null || _a === void 0 ? void 0 : _a.entity) === null || _b === void 0 ? void 0 : _b.id) === entity.id && ((_c = goal.goal) === null || _c === void 0 ? void 0 : _c.rangeSq) === distance * distance; });
+        if (oldGoals !== this.goalArray.goals.length || this.goalArray.goals.length === 0) {
+            this.goalArray.push(new GoalFollow(entity, distance));
+            this.goalArray.push(new GoalInvert(new GoalFollow(entity, distance - 1)));
+            this.bot.pathfinder.setGoal(this.goalArray, dynamic);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 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, followDistance, invertDistance) {
+        const oldGoals = this.goalArray.goals.length;
+        this.goalArray.goals = this.goalArray.goals.filter((goal) => {
+            var _a;
+            return ((_a = goal.entity) === null || _a === void 0 ? void 0 : _a.id) === entity.id && goal.rangeSq === followDistance * followDistance;
+        });
+        if (oldGoals !== this.goalArray.goals.length || !this.bot.pathfinder.isMoving() || this.goalArray.goals.length === 0) {
+            if (this.goalArray.goals.length > 0) {
+                this.goalArray.goals = [];
+            }
+            this.goalArray.push(new GoalFollow(entity, followDistance));
+            this.goalArray.push(new GoalInvert(new GoalFollow(entity, invertDistance !== null && invertDistance !== void 0 ? invertDistance : followDistance - 0.5)));
+            this.bot.pathfinder.setGoal(this.goalArray, true);
+            return true;
+        }
+        return false;
+    }
+    forceLook(yaw, pitch, update = false) {
+        const notchianYawAndPitch = { yaw: this.bot.util.math.toNotchianYaw(yaw), pitch: this.bot.util.math.toNotchianPitch(pitch) };
+        this.bot._client.write("look", Object.assign(Object.assign({}, notchianYawAndPitch), { onGround: false }));
+        if (update) {
+            // this.bot.entity.yaw = yaw;
+            // this.bot.entity.pitch = pitch
+            this.bot.look(yaw, pitch, true);
+        }
+    }
+    forceLookAt(pos, update = false, trueForce = false) {
+        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) };
+        if (nyp.yaw !== this.lastYaw || nyp.pitch !== this.lastPitch || trueForce) {
+            this.bot._client.write("look", Object.assign(Object.assign({}, nyp), { onGround: false }));
+            if (update) {
+                // this.bot.entity.yaw = yaw;
+                // this.bot.entity.pitch = pitch
+                this.bot.lookAt(pos, true);
+            }
+        }
+    }
+    lazyTeleport(endPos) { }
+}
+exports.MovementFunctions = MovementFunctions;