@nxg-org/mineflayer-util-plugin 1.0.0

package/src/entityFunctions.ts

@@ -0,0 +1,71 @@
+import type { Bot } from "mineflayer";
+import type { Entity } from "prismarine-entity";
+import type { Vec3 } from "vec3";
+import { AABB } from "./calcs/aabb";
+
+export class EntityFunctions {
+    healthSlot: number = 7;
+    constructor(public bot: Bot) {
+        this.bot.on("spawn", async () => {
+            // 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?: Entity): boolean {
+        return ((entity ?? this.bot.entity).metadata[6] as any) === 1; //as any & (1 | 0)) === (1 | 0);
+    }
+
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     *
+     * Checks if offhand is activated.
+     * @returns boolean
+     */
+    isOffHandActive(entity?: Entity): boolean {
+        return ((entity ?? this.bot.entity).metadata[6] as any) === 1; //& (1 | 2)) === (1 | 2);
+    }
+
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     * @param metadata metadata from Prismarine-Entity Entity.
+     * @returns
+     */
+    getHealth(entity?: Entity): number {
+        entity = 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 ? this.bot.entity.health ?? 0 : 0;
+        if (health === 0) console.log(this.healthSlot, entity.metadata);
+        // console.log(health + (Number(metadata[this.healthSlot + 4]) ?? 0))
+        return health + (Number(metadata[this.healthSlot + 4]) ?? 0);
+    }
+
+    getDistanceToEntity(entity: Entity): number {
+        return this.getDistanceBetweenEntities(this.bot.entity, entity);
+    }
+
+    getDistanceBetweenEntities(first: Entity, second: Entity): number {
+        return first.position.distanceTo(second.position);
+    }
+
+    getEntityAABB(entity: { position: Vec3; height: number; width?: number }): AABB {
+        const w = entity.width ?? entity.height / 2;
+        const { x, y, z } = entity.position;
+        return new AABB(-w, 0, -w, w, entity.height, w).offset(x, y, z);
+    }
+}

package/src/filterFunctions.ts

@@ -0,0 +1,54 @@
+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 class FilterFunctions {
+    public specificNames: string[] = [];
+    public botNames: string[] = [];
+    constructor(private bot: Bot) {}
+
+    addBotName(name: string): void {
+        this.botNames.push(name);
+    }
+
+    getNearestEntity(func: (entity: Entity, ...args: any[]) => boolean, ...args: any[]): Entity | null {
+        return this.bot.nearestEntity((entity: Entity) => func(entity, ...args));
+    }
+
+    static getNearestEntity(bot: Bot, func: (entity: Entity, ...args: any[]) => boolean, ...args: any[]): Entity | null {
+        return bot.nearestEntity((entity: Entity) => func(entity, ...args));
+    }
+
+    allButOtherBotsFilter(): Entity | null {
+        return this.getNearestEntity((e: Entity) => e.type === "player" && (!this.botNames?.includes(e.username ?? "") ?? true));
+    }
+
+    static allButOtherBotsFilter(bot: Bot, ...names: string[]): Entity | null {
+        return FilterFunctions.getNearestEntity(bot, (e: Entity) => e.type === "player" && !names.includes(e.username ?? ""));
+    }
+
+    specificNamesFilter(): Entity | null {
+        return this.getNearestEntity((e: Entity) => e.type === "player" && (this.specificNames?.includes(e.username ?? "") ?? true));
+    }
+
+    static specificNamesFilter(bot: Bot, ...names: string[]): Entity | null {
+        return FilterFunctions.getNearestEntity(bot, (e: Entity) => e.type === "player" && names.includes(e.username ?? ""));
+    }
+
+    nearestCrystalFilter(): Entity | null {
+        return this.getNearestEntity((e: Entity) => e.name === "ender_crystal");
+    }
+
+    static nearestCrystalFilter(bot: Bot): Entity | null {
+        return FilterFunctions.getNearestEntity(bot, (e: Entity) => e.name === "ender_crystal");
+    }
+
+    entityAtPosition(position: Vec3) {
+        return this.getNearestEntity((entity: Entity) => entity.position.offset(-0.5, -1, -0.5).equals(position));
+    }
+
+    static entityAtPosition(bot: Bot, position: Vec3) {}
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+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;
+        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) {
+    bot.util = new UtilFunctions(bot);
+}

package/src/inventoryFunctions.ts

@@ -0,0 +1,187 @@
+import { Bot, EquipmentDestination } from "mineflayer";
+import { Item } from "prismarine-item";
+import { promisify } from "util";
+import { BuiltInPriorityOptions } from "./utilFunctions";
+const sleep = 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.
+ */
+export class InventoryFunctions {
+    private _equippingMainHand: boolean = false;
+    private _equippingOffHand: boolean = false;
+    private _equippingOtherSlot: boolean = false;
+    public usingMainHand: boolean = false;
+    public usingOffHand: boolean = false;
+
+    constructor(public bot: Bot) {}
+
+    public set equippingOtherSlot(value: boolean) {
+        if (this._equippingOtherSlot === value) return;
+        if (value) this.bot.emit("startedEquippingOtherSlot");
+        else this.bot.emit("stoppedEquippingOtherSlot");
+        this._equippingOtherSlot = value;
+    }
+
+    public get equippingOtherSlot(): boolean {
+        return this._equippingOtherSlot;
+    }
+
+    public set equippingMainHand(value: boolean) {
+        if (this._equippingMainHand === value) return;
+        if (value) this.bot.emit("startedEquippingMainHand");
+        else this.bot.emit("stoppedEquippingMainHand");
+        this._equippingMainHand = value;
+    }
+
+    public get equippingMainHand(): boolean {
+        return this._equippingMainHand;
+    }
+
+    public set equippingOffHand(value: boolean) {
+        if (this._equippingOffHand === value) return;
+        if (value) this.bot.emit("startedEquippingOffHand");
+        else this.bot.emit("stoppedEquippingOffHand");
+        this._equippingOffHand = value;
+    }
+
+    public get equippingOffHand(): boolean {
+        return this._equippingOffHand;
+    }
+
+    getAllItems(): Item[] {
+        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: EquipmentDestination): Item[] {
+        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?: boolean): Item | null {
+        return this.bot.inventory.slots[this.bot.getEquipmentDestSlot(this.getHand(offhand))];
+    }
+
+    getHand(offhand: boolean = false): "hand" | "off-hand" {
+        return offhand ? "off-hand" : "hand";
+    }
+
+    findItemByID(itemId: number, metadata?: number): Item | null {
+        const potentialMatches = this.getAllItems().filter((item) => item.type === itemId);
+        if (metadata) return potentialMatches.find((item) => item.metadata === metadata) ?? null;
+        return potentialMatches[0] ?? null;
+    }
+
+    findItem(name: string, metadata?: number) {
+        //[...this.getAllItems(), this.bot.inventory.selectedItem!]
+        const potentialMatches = this.getAllItems().filter((item) => item?.name.includes(name));
+        if (metadata) return potentialMatches.find((item) => item.metadata === metadata) ?? null;
+        return potentialMatches[0] ?? null;
+    }
+
+    //alias.
+    has(name: string, metadata?: number) {
+        return !!this.findItem(name, metadata);
+    }
+
+    async equipItemRaw(item: Item, dest: EquipmentDestination): Promise<boolean> {
+        if (this.bot.inventory.slots[this.bot.getEquipmentDestSlot(dest)] === item) return true;
+        await this.bot.equip(item, dest);
+        return false;
+    }
+
+    async equipItem(name: string, dest: EquipmentDestination, options: BuiltInPriorityOptions): Promise<number> {
+        if (this.bot.inventory.slots[this.bot.getEquipmentDestSlot(dest)]?.name.includes(name)) return 1;
+        const item = this.getAllItemsExceptCurrent(dest).find((item) => item?.name.includes(name));
+        if (!!item) {
+            await this.bot.util.builtInsPriority(options, this.bot.equip, item, dest);
+            return 0;
+        }
+        return 2;
+    }
+
+    async equipMainHand(name: string, options: BuiltInPriorityOptions = { group: "inventory", priority: 1 }): Promise<number> {
+        while (this._equippingMainHand) {
+            await sleep(0);
+        }
+        return await this.equipMainHandNoWait(name, options);
+    }
+
+    async equipOffHand(name: string, options: BuiltInPriorityOptions = { group: "inventory", priority: 1 }): Promise<number> {
+        while (this._equippingOffHand) {
+            await sleep(0);
+        }
+        return await this.equipOffHandNoWait(name, options);
+    }
+
+    async equipSlot(
+        name: string,
+        destination: EquipmentDestination,
+        options: BuiltInPriorityOptions = { group: "inventory", priority: 1 }
+    ): Promise<number> {
+        while (this._equippingOtherSlot) {
+            await sleep(0);
+        }
+        return await this.equipSlotNoWait(name, destination, options);
+    }
+
+    async equipMainHandNoWait(name: string, options: BuiltInPriorityOptions): Promise<number> {
+        if (this._equippingMainHand) return 3;
+        this._equippingMainHand = true;
+        const result = await this.equipItem(name, "hand", options);
+        this._equippingMainHand = false;
+        return result;
+    }
+
+    async equipOffHandNoWait(name: string, options: BuiltInPriorityOptions): Promise<number> {
+        if (this._equippingOffHand) return 3;
+        this.equippingOffHand = true;
+        const result = await this.equipItem(name, "off-hand", options);
+        this.equippingOffHand = false;
+        return result;
+    }
+
+    async equipSlotNoWait(name: string, dest: EquipmentDestination, options: BuiltInPriorityOptions) {
+        if (this._equippingOtherSlot) return 3;
+        this.equippingOtherSlot = true;
+        const result = await this.equipItem(name, dest, options);
+        this.equippingOtherSlot = false;
+        return result;
+    }
+
+    async customEquip(item: Item, destination: EquipmentDestination, retries: number = 1) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await this.bot.equip(item, destination);
+                return true;
+            } catch (error) {
+                if (this.bot.inventory.selectedItem) {
+                    const slot = this.bot.inventory.firstEmptyInventorySlot(false) || -999;
+                    try {
+                        await this.bot.clickWindow(slot, 0, 0);
+                    } catch (error) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

package/src/mathUtil.ts

@@ -0,0 +1,56 @@
+import { Bot } from "mineflayer";
+import { Vec3 } from "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;
+
+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) {
+        const result = numerator % denominator;
+        return result < 0 ? result + denominator : result;
+    }
+
+    toRadians(degrees: number) {
+        return TO_RAD * degrees;
+    }
+
+    toDegrees(radians: number) {
+        return TO_DEG * radians;
+    }
+
+    fromNotchianYaw(yaw: number) {
+        return this.euclideanMod(PI - this.toRadians(yaw), PI_2);
+    }
+
+    fromNotchianPitch(pitch: number) {
+        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);
+    }
+
+    pointToYawAndPitch(bot: Bot, point: Vec3) {
+        const delta = point.minus(bot.entity.position.offset(0, bot.entity.height, 0));
+        return this.dirToYawAndPitch(delta);
+    }
+
+    dirToYawAndPitch(dir: Vec3) {
+        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 };
+    }
+}

package/src/movementFunctions.ts

@@ -0,0 +1,116 @@
+import type { Bot } from "mineflayer";
+import type { Entity } from "prismarine-entity";
+import type { Vec3 } from "vec3";
+import { goals } from "mineflayer-pathfinder";
+
+const { GoalCompositeAll, GoalInvert, GoalFollow } = goals;
+
+export class MovementFunctions {
+    goalArray = new GoalCompositeAll();
+    lastYaw: number = 0;
+    lastPitch: number = 0;
+    constructor(public bot: Bot) {}
+
+    /**
+     * Fuckin' mineflayer-pathfinder still doesn't have typings.
+     * Pain in my goddamn ass.
+     * @returns have the goal changed
+     */
+    addGoal(goal: any): boolean {
+        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: any, dynamic: boolean = false): boolean {
+        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(): boolean {
+        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: Entity, distance: number, dynamic: boolean = true): boolean {
+        const oldGoals = this.goalArray.goals.length;
+        this.goalArray.goals = this.goalArray.goals.filter(
+            (goal: any) => goal.goal?.entity?.id === entity.id && goal.goal?.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: Entity, followDistance: number, invertDistance?: number): boolean {
+        const oldGoals = this.goalArray.goals.length;
+        this.goalArray.goals = (this.goalArray.goals as any[]).filter((goal) => {
+            return goal.entity?.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 ?? followDistance - 0.5)));
+            this.bot.pathfinder.setGoal(this.goalArray, true);
+            return true;
+        }
+
+        return false;
+    }
+
+    forceLook(yaw: number, pitch: number, update: boolean = false) {
+        const notchianYawAndPitch = { yaw: this.bot.util.math.toNotchianYaw(yaw), pitch: this.bot.util.math.toNotchianPitch(pitch) };
+        this.bot._client.write("look", { ...notchianYawAndPitch, onGround: false });
+        if (update) {
+            // this.bot.entity.yaw = yaw;
+            // this.bot.entity.pitch = pitch
+            this.bot.look(yaw, pitch, true);
+        }
+    }
+
+    forceLookAt(pos: Vec3, update: boolean = false, trueForce: boolean = 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", { ...nyp, onGround: false });
+            if (update) {
+                // this.bot.entity.yaw = yaw;
+                // this.bot.entity.pitch = pitch
+                this.bot.lookAt(pos, true);
+            }
+        }
+    }
+
+    lazyTeleport(endPos: Vec3) {}
+}