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

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/{src/calcs/aabb.ts → lib/calcs/aabb.js}

@@ -1,14 +1,9 @@
-import { Vec3 } from "vec3";
-
-export class AABB {
-    public minX: number;
-    public minY: number;
-    public minZ: number;
-    public maxX: number;
-    public maxY: number;
-    public maxZ: number;
-
-    constructor(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number) {
+"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;
@@ -16,12 +11,10 @@ export class AABB {
         this.maxY = y1;
         this.maxZ = z1;
     }
-
-    static fromVecs(min: Vec3, max: Vec3) {
+    static fromVecs(min, max) {
         return new AABB(min.x, min.y, min.z, max.x, max.y, max.z);
     }
-
-    set(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number) {
+    set(x0, y0, z0, x1, y1, z1) {
         this.minX = x0;
         this.minY = y0;
         this.minZ = z0;
@@ -29,23 +22,18 @@ export class AABB {
         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(this.minX, this.minY, this.minZ), 1: new Vec3(this.maxX, this.maxY, this.maxZ) };
+        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);
@@ -54,21 +42,22 @@ export class AABB {
         this.maxY = Math.floor(this.maxY);
         this.maxZ = Math.floor(this.maxZ);
     }
-
-    extend(dx: number, dy: number, dz: number) {
-        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;
-
+    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: number, y: number, z: number) {
+    contract(x, y, z) {
         this.minX += x;
         this.minY += y;
         this.minZ += z;
@@ -77,8 +66,7 @@ export class AABB {
         this.maxZ -= z;
         return this;
     }
-
-    expand(x: number, y: number, z: number) {
+    expand(x, y, z) {
         this.minX -= x;
         this.minY -= y;
         this.minZ -= z;
@@ -87,8 +75,7 @@ export class AABB {
         this.maxZ += z;
         return this;
     }
-
-    offset(x: number, y: number, z: number) {
+    offset(x, y, z) {
         this.minX += x;
         this.minY += y;
         this.minZ += z;
@@ -97,61 +84,57 @@ export class AABB {
         this.maxZ += z;
         return this;
     }
-
-    computeOffsetX(other: AABB, offsetX: number) {
+    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) {
+            }
+            else if (offsetX < 0.0 && other.minX >= this.maxX) {
                 offsetX = Math.max(this.maxX - other.minX, offsetX);
             }
         }
         return offsetX;
     }
-
-    computeOffsetY(other: AABB, offsetY: number) {
+    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) {
+            }
+            else if (offsetY < 0.0 && other.minY >= this.maxY) {
                 offsetY = Math.max(this.maxY - other.minY, offsetY);
             }
         }
         return offsetY;
     }
-
-    computeOffsetZ(other: AABB, offsetZ: number) {
+    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) {
+            }
+            else if (offsetZ < 0.0 && other.minZ >= this.maxZ) {
                 offsetZ = Math.max(this.maxZ - other.minZ, offsetZ);
             }
         }
         return offsetZ;
     }
-
-    intersects(other: AABB) {
-        return (
-            this.minX < other.maxX &&
+    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
-        );
+            this.maxZ > other.minZ);
     }
-
-    intersectsRay(origin: Vec3, direction: Vec3) {
+    intersectsRay(origin, direction) {
         const d = this.distanceFromRay(origin, direction);
         if (d === Infinity) {
             return null;
-        } else {
-            return new Vec3(origin.x + direction.x * d, origin.y + direction.y * d, origin.z + direction.z * d);
+        }
+        else {
+            return new vec3_1.Vec3(origin.x + direction.x * d, origin.y + direction.y * d, origin.z + direction.z * d);
         }
     }
-
-    distanceFromRay(origin: Vec3, direction: Vec3) {
+    distanceFromRay(origin, direction) {
         const ro = origin.toArray();
         const rd = direction.normalize().toArray();
         const aabb = this.toMinAndMaxArrays();
@@ -159,17 +142,14 @@ export class AABB {
         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:
@@ -187,26 +167,22 @@ export class AABB {
                 console.log("fuck", dimHi < lo, dimLo > hi);
                 return Infinity;
             }
-
-            if (dimLo > lo) lo = dimLo;
-            if (dimHi < hi) hi = dimHi;
+            if (dimLo > lo)
+                lo = dimLo;
+            if (dimHi < hi)
+                hi = dimHi;
         }
-
         return lo > hi ? Infinity : lo;
     }
-
-    equals(other: AABB): boolean {
-        return (
-            this.minX === other.minX &&
+    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
-        );
+            this.maxZ === other.maxZ);
     }
-
-    distanceTo(pos: Vec3, heightOffset: number = 0): number {
+    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);
@@ -214,5 +190,5 @@ export class AABB {
         return Math.sqrt(dx * dx + dy * dy + dz * dz);
     }
 }
-
-export default AABB;
+exports.AABB = AABB;
+exports.default = AABB;

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,49 @@
+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 number
+     */
+    getHealth(entity?: Entity): number;
+    /**
+     *
+     * @param metadata Must be FULL metadata object.
+     * @returns number
+     */
+    getHealthFromMetadata(metadata: object[]): number;
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     * @param metadata metadata from Prismarine-Entity Entity.
+     * @returns
+     */
+    getHealthChange(packetMetadata: any, entity: Entity): number;
+    getDistanceToEntity(entity: Entity): number;
+    getDistanceBetweenEntities(first: Entity, second: Entity): number;
+    getEntityAABB(entity: {
+        position: Vec3;
+        height: number;
+        width?: number;
+    }): AABB;
+    private parseMetadata;
+}

package/lib/entityFunctions.js

@@ -0,0 +1,104 @@
+"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 number
+     */
+    getHealth(entity) {
+        var _a, _b;
+        entity !== null && entity !== void 0 ? entity : (entity = this.bot.entity);
+        const metadata = entity.metadata;
+        const healthSlot = this.healthSlot; //metadata[this.healthSlot] ? this.healthSlot : metadata.findIndex((met) => Number(met) > 1 && Number(met) <= 20);
+        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);
+    }
+    /**
+     *
+     * @param metadata Must be FULL metadata object.
+     * @returns number
+     */
+    getHealthFromMetadata(metadata) {
+        var _a;
+        return (_a = (Number(metadata[this.healthSlot]) + Number(metadata[this.healthSlot + 4]))) !== null && _a !== void 0 ? _a : undefined;
+    }
+    /**
+     * TODO: Version specific right now. Generalize. Unknown method.
+     * @param metadata metadata from Prismarine-Entity Entity.
+     * @returns
+     */
+    getHealthChange(packetMetadata, entity) {
+        const oldMetadata = entity.metadata;
+        const newMetadata = this.parseMetadata(packetMetadata, oldMetadata);
+        return this.getHealthFromMetadata(newMetadata) - this.getHealthFromMetadata(oldMetadata);
+    }
+    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);
+    }
+    //Stolen from mineflayer.
+    parseMetadata(packetMetadata, entityMetadata = {}) {
+        if (packetMetadata !== undefined) {
+            for (const { key, value } of packetMetadata) {
+                entityMetadata[key] = value;
+            }
+        }
+        return entityMetadata;
+    }
+}
+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;