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

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

@@ -1,109 +1,102 @@
-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) {}
-
+"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: any): boolean {
-        if (this.goalArray.goals.find((inGoal) => inGoal === goal)) return false;
+    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: any, dynamic: boolean = false): boolean {
+    setOnlyGoal(goal, dynamic = false) {
         const goalArr = [goal];
-        if (this.goalArray.goals === goalArr) return false;
+        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;
+    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: Entity, distance: number, dynamic: boolean = true): boolean {
+    retreatFromEntity(entity, distance, dynamic = true) {
         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
-        );
+        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.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 {
+    followEntityWithRespectRange(entity, followDistance, invertDistance) {
         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;
+        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 ?? followDistance - 0.5)));
+            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: number, pitch: number, update: boolean = 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", { ...notchianYawAndPitch, onGround: false });
+        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: Vec3, update: boolean = false, trueForce: boolean = false) {
+    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", { ...nyp, onGround: false });
+            this.bot._client.write("look", Object.assign(Object.assign({}, nyp), { onGround: false }));
             if (update) {
                 // this.bot.entity.yaw = yaw;
                 // this.bot.entity.pitch = pitch
@@ -111,6 +104,6 @@ export class MovementFunctions {
             }
         }
     }
-
-    lazyTeleport(endPos: Vec3) {}
+    lazyTeleport(endPos) { }
 }
+exports.MovementFunctions = MovementFunctions;

package/lib/predictiveFunctions.d.ts

@@ -0,0 +1,25 @@
+import type { Bot } from "mineflayer";
+import type { Entity } from "prismarine-entity";
+import { Vec3 } from "vec3";
+import { Overwrites, PredictiveWorld } from "./worldRelated/predictiveWorld";
+export declare const ARMOR_THOUGHNESS_KEY = "generic.armorToughness";
+export declare class PredictiveFunctions {
+    private bot;
+    private damageMultiplier;
+    private armorToughnessKey;
+    private armorProtectionKey;
+    private resistanceIndex;
+    world: PredictiveWorld;
+    constructor(bot: Bot);
+    getDamageWithEffects(damage: number, effects: {
+        [id: string]: {
+            id: number;
+            amplifier: number;
+            duration: number;
+        };
+    }): number;
+    placeBlocks(blocks: Overwrites): void;
+    removePredictedBlocks(positions: Vec3[], force?: boolean): void;
+    selfExplosionDamage(sourcePos: Vec3, power: number, rawDamages?: boolean): number;
+    getExplosionDamage(targetEntity: Entity, sourcePos: Vec3, power: number, rawDamages?: boolean): number;
+}

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

@@ -1,27 +1,24 @@
-import type { Effects } from "minecraft-data";
-import type { Bot } from "mineflayer";
-import type { Entity } from "prismarine-entity";
-import type { Item, NormalizedEnchant } from "prismarine-item";
-import md from "minecraft-data";
-import { Vec3 } from "vec3";
-import { Overwrites, PredictiveWorld } from "./worldRelated/predictiveWorld";
-import type { Block } from "prismarine-block";
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictiveFunctions = exports.ARMOR_THOUGHNESS_KEY = void 0;
+const minecraft_data_1 = __importDefault(require("minecraft-data"));
+const vec3_1 = require("vec3");
+const predictiveWorld_1 = require("./worldRelated/predictiveWorld");
 const armorPieces = ["head", "torso", "legs", "feet"];
-
 // https://minecraft.fandom.com/wiki/Explosion
 // Use bot.world, there's no typing yet.
-function calcExposure(playerPos: Vec3, explosionPos: Vec3, world: any) {
+function calcExposure(playerPos, explosionPos, world) {
     const dx = 1 / (0.6 * 2 + 1);
     const dy = 1 / (1.8 * 2 + 1);
     const dz = 1 / (0.6 * 2 + 1);
-
     const d3 = (1 - Math.floor(1 / dx) * dx) / 2;
     const d4 = (1 - Math.floor(1 / dz) * dz) / 2;
-
     let sampled = 0;
     let exposed = 0;
-    const pos = new Vec3(0, 0, 0);
+    const pos = new vec3_1.Vec3(0, 0, 0);
     for (pos.y = playerPos.y; pos.y <= playerPos.y + 1.8; pos.y += 1.8 * dy) {
         for (pos.x = playerPos.x - 0.3 + d3; pos.x <= playerPos.x + 0.3; pos.x += 0.6 * dx) {
             for (pos.z = playerPos.z - 0.3 + d4; pos.z <= playerPos.z + 0.3; pos.z += 0.6 * dz) {
@@ -36,84 +33,75 @@ function calcExposure(playerPos: Vec3, explosionPos: Vec3, world: any) {
     }
     return exposed / sampled;
 }
-
 // https://minecraft.fandom.com/wiki/Armor#Damage_protection
-function getDamageAfterAbsorb(damages: number, armorValue: number, toughness: number) {
+function getDamageAfterAbsorb(damages, armorValue, toughness) {
     const var3 = 2 + toughness / 4;
     const var4 = Math.min(Math.max(armorValue - damages / var3, armorValue * 0.2), 20);
     return damages * (1 - var4 / 25);
 }
-
 // https://minecraft.fandom.com/wiki/Attribute#Operations
-function getAttributeValue(prop: any) {
+function getAttributeValue(prop) {
     let X = prop.value;
     for (const mod of prop.modifiers) {
-        if (mod.operation !== 0) continue;
+        if (mod.operation !== 0)
+            continue;
         X += mod.amount;
     }
     let Y = X;
     for (const mod of prop.modifiers) {
-        if (mod.operation !== 1) continue;
+        if (mod.operation !== 1)
+            continue;
         Y += X * mod.amount;
     }
     for (const mod of prop.modifiers) {
-        if (mod.operation !== 2) continue;
+        if (mod.operation !== 2)
+            continue;
         Y += Y * mod.amount;
     }
     return Y;
 }
-
-function getDamageWithEnchantments(damage: number, equipment: Item[]) {
+function getDamageWithEnchantments(damage, equipment) {
     const enchantments = equipment.some((e) => !!e)
         ? equipment
-              .map(
-                  (armor) =>
-                      armor?.enchants
-                          .map((enchant: NormalizedEnchant) => {
-                              switch (enchant?.name) {
-                                  case "protection":
-                                      return enchant.lvl;
-                                  case "blast_protection":
-                                      return enchant.lvl * 2;
-                                  default:
-                                      return 0;
-                              }
-                          })
-                          .reduce((b: number, a: number) => b + a, 0) ?? [0]
-              )
-              .reduce((b: number, a: number) => b + a, 0)
+            .map((armor) => {
+            var _a;
+            return (_a = armor === null || armor === void 0 ? void 0 : armor.enchants.map((enchant) => {
+                switch (enchant === null || enchant === void 0 ? void 0 : enchant.name) {
+                    case "protection":
+                        return enchant.lvl;
+                    case "blast_protection":
+                        return enchant.lvl * 2;
+                    default:
+                        return 0;
+                }
+            }).reduce((b, a) => b + a, 0)) !== null && _a !== void 0 ? _a : [0];
+        })
+            .reduce((b, a) => b + a, 0)
         : 0;
     return damage * (1 - Math.min(enchantments, 20) / 25);
 }
-
 const DIFFICULTY_VALUES = {
     peaceful: 0,
     easy: 1,
     normal: 2,
     hard: 3,
 };
-
-export const ARMOR_THOUGHNESS_KEY = "generic.armorToughness";
-const AIR_BLOCK = {type: 0};
-
-export class PredictiveFunctions {
-    private damageMultiplier = 7; // for 1.12+ 8 for 1.8 TODO check when the change occur (likely 1.9)
-    private armorToughnessKey: string; // was renamed in 1.16
-    private armorProtectionKey: string;
-
-    private resistanceIndex = "11";
-
-    public world: PredictiveWorld;
-
-    constructor(private bot: Bot) {
-        if ((require('minecraft-data') as (typeof import('minecraft-data')))(bot.version).isNewerOrEqualTo("1.16")){
+exports.ARMOR_THOUGHNESS_KEY = "generic.armorToughness";
+const AIR_BLOCK = { type: 0 };
+class PredictiveFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this.damageMultiplier = 7; // for 1.12+ 8 for 1.8 TODO check when the change occur (likely 1.9)
+        this.resistanceIndex = "11";
+        if (require('minecraft-data')(bot.version).isNewerOrEqualTo("1.16")) {
             this.armorToughnessKey = "generic.armorToughness";
             this.armorProtectionKey = "generic.armor";
-        } else {
+        }
+        else {
             this.armorToughnessKey = "generic.armorToughness";
             this.armorProtectionKey = "generic.armor";
         }
-        const effects = md(bot.version).effects;
+        const effects = (0, minecraft_data_1.default)(bot.version).effects;
         for (const effectId in effects) {
             const effect = effects[effectId];
             if (effect.name.includes("resistance")) {
@@ -121,28 +109,25 @@ export class PredictiveFunctions {
                 break;
             }
         }
-
-        this.world = new PredictiveWorld(bot);
+        this.world = new predictiveWorld_1.PredictiveWorld(bot);
     }
-
     //There's a mistyping in mineflayer. Effect[] is not accurate. You cannot map over it.
-    getDamageWithEffects(damage: number, effects: { [id: string]: { id: number; amplifier: number; duration: number } }) {
-        const resistanceLevel = effects?.[this.resistanceIndex]?.amplifier ?? 0;
+    getDamageWithEffects(damage, effects) {
+        var _a, _b;
+        const resistanceLevel = (_b = (_a = effects === null || effects === void 0 ? void 0 : effects[this.resistanceIndex]) === null || _a === void 0 ? void 0 : _a.amplifier) !== null && _b !== void 0 ? _b : 0;
         return damage * (1 - resistanceLevel / 5);
     }
-
-    placeBlocks(blocks: Overwrites) {
-        this.world.setBlocks(blocks)
+    placeBlocks(blocks) {
+        this.world.setBlocks(blocks);
     }
-
-    removePredictedBlocks(positions: Vec3[], force: boolean = false) {
-        this.world.removeBlocks(positions, force)
+    removePredictedBlocks(positions, force = false) {
+        this.world.removeBlocks(positions, force);
     }
-
-    selfExplosionDamage(sourcePos: Vec3, power: number, rawDamages = false) {
+    selfExplosionDamage(sourcePos, power, rawDamages = false) {
         const distance = this.bot.entity.position.distanceTo(sourcePos);
         const radius = 2 * power;
-        if (distance >= radius) return 0;
+        if (distance >= radius)
+            return 0;
         const exposure = calcExposure(this.bot.entity.position, sourcePos, this.world);
         const impact = (1 - distance / radius) * exposure;
         let damages = Math.floor((impact * impact + impact) * this.damageMultiplier * power + 1);
@@ -155,16 +140,16 @@ export class PredictiveFunctions {
             damages = getDamageAfterAbsorb(damages, armor, armorToughness);
             const equipment = armorPieces.map((piece) => this.bot.inventory.slots[this.bot.getEquipmentDestSlot(piece)]);
             damages = getDamageWithEnchantments(damages, equipment);
-            damages = this.getDamageWithEffects(damages, this.bot.entity.effects as any);
+            damages = this.getDamageWithEffects(damages, this.bot.entity.effects);
             damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
         }
         return Math.floor(damages);
     }
-
-    getExplosionDamage(targetEntity: Entity, sourcePos: Vec3, power: number, rawDamages = false) {
+    getExplosionDamage(targetEntity, sourcePos, power, rawDamages = false) {
         const distance = targetEntity.position.distanceTo(sourcePos);
         const radius = 2 * power;
-        if (distance >= radius) return 0;
+        if (distance >= radius)
+            return 0;
         const exposure = calcExposure(targetEntity.position, sourcePos, this.world);
         const impact = (1 - distance / radius) * exposure;
         let damages = Math.floor((impact * impact + impact) * this.damageMultiplier * power + 1);
@@ -176,8 +161,7 @@ export class PredictiveFunctions {
             const armorToughness = getAttributeValue(targetEntity.attributes[this.armorToughnessKey]);
             damages = getDamageAfterAbsorb(damages, armor, armorToughness);
             damages = getDamageWithEnchantments(damages, targetEntity.equipment);
-            damages = this.getDamageWithEffects(damages, targetEntity.effects as any);
-
+            damages = this.getDamageWithEffects(damages, targetEntity.effects);
             if (targetEntity.type === "player") {
                 damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
             }
@@ -185,3 +169,4 @@ export class PredictiveFunctions {
         return Math.floor(damages);
     }
 }
+exports.PredictiveFunctions = PredictiveFunctions;

package/lib/utilFunctions.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import type { Bot, PrioGroups } from "mineflayer";
+import { EntityFunctions } from "./entityFunctions";
+import { FilterFunctions } from "./filterFunctions";
+import { InventoryFunctions } from "./inventoryFunctions";
+import { MovementFunctions } from "./movementFunctions";
+import { PredictiveFunctions } from "./predictiveFunctions";
+import { MathFunctions } from "./mathUtil";
+import { CommonSense } from "./commonSense";
+import { WorldFunctions } from "./WorldFunctions";
+export declare type BuiltInPriorityOptions = {
+    group: PrioGroups;
+    priority: number;
+    returnIfRunning?: boolean;
+    errCancel?: boolean;
+};
+export declare type CustomPriorityOptions = {
+    priority: number;
+    group?: PrioGroups;
+    returnIfRunning?: boolean;
+    errCancel?: boolean;
+};
+export declare class UtilFunctions {
+    bot: Bot;
+    inv: InventoryFunctions;
+    move: MovementFunctions;
+    entity: EntityFunctions;
+    predict: PredictiveFunctions;
+    filters: FilterFunctions;
+    math: MathFunctions;
+    commonSense: CommonSense;
+    world: WorldFunctions;
+    private builtInsPriorityStore;
+    private customPriorityStore;
+    private builtInCurrentExecuting;
+    private customCurrentExecuting;
+    constructor(bot: Bot);
+    sleep: typeof import("timers/promises").setTimeout;
+    isBuiltInsEmpty(name?: string): boolean;
+    isCustomEmpty(name?: string): boolean;
+    /**
+     *
+     * @param object \{priority, errCancel} => priority of function (highest order first), throw error if already running a function.
+     * @param func any custom function.
+     * @param args the arguments of passed in function.
+     * @returns Error if errCancel and already executing, otherwise result of function.
+     */
+    customPriority<K extends (...args: any) => any>({ priority, group, returnIfRunning, errCancel }: CustomPriorityOptions, func: K, ...args: Parameters<K>): number | Promise<ReturnType<K> | Error>;
+    builtInsPriority<K extends (...args: any) => any>({ group, priority, returnIfRunning, errCancel }: BuiltInPriorityOptions, func: K, ...args: Parameters<K>): number | Promise<ReturnType<K> | Error>;
+}

package/lib/utilFunctions.js

@@ -0,0 +1,140 @@
+"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.UtilFunctions = void 0;
+const entityFunctions_1 = require("./entityFunctions");
+const filterFunctions_1 = require("./filterFunctions");
+const inventoryFunctions_1 = require("./inventoryFunctions");
+const movementFunctions_1 = require("./movementFunctions");
+const util_1 = require("util");
+const predictiveFunctions_1 = require("./predictiveFunctions");
+const mathUtil_1 = require("./mathUtil");
+const commonSense_1 = require("./commonSense");
+const WorldFunctions_1 = require("./WorldFunctions");
+class UtilFunctions {
+    constructor(bot) {
+        this.bot = bot;
+        this.sleep = (0, util_1.promisify)(setTimeout);
+        this.inv = new inventoryFunctions_1.InventoryFunctions(bot);
+        this.move = new movementFunctions_1.MovementFunctions(bot);
+        this.entity = new entityFunctions_1.EntityFunctions(bot);
+        this.predict = new predictiveFunctions_1.PredictiveFunctions(bot);
+        this.filters = new filterFunctions_1.FilterFunctions(bot);
+        this.commonSense = new commonSense_1.CommonSense(bot);
+        this.world = new WorldFunctions_1.WorldFunctions(bot);
+        this.math = new mathUtil_1.MathFunctions();
+        this.builtInsPriorityStore = {};
+        this.customPriorityStore = {};
+        this.builtInCurrentExecuting = {};
+        this.customCurrentExecuting = {};
+    }
+    isBuiltInsEmpty(name) {
+        var _a;
+        if (name) {
+            return !((_a = this.builtInsPriorityStore[name]) === null || _a === void 0 ? void 0 : _a.length) || !this.builtInCurrentExecuting[name];
+        }
+        else {
+            return !Object.values(this.builtInsPriorityStore).length || !Object.values(this.builtInCurrentExecuting).length;
+        }
+    }
+    isCustomEmpty(name) {
+        var _a;
+        if (name) {
+            return !((_a = this.customPriorityStore[name]) === null || _a === void 0 ? void 0 : _a.length) && !this.customCurrentExecuting[name];
+        }
+        else {
+            return !Object.values(this.customPriorityStore).length && !Object.values(this.customCurrentExecuting).length;
+        }
+    }
+    /**
+     *
+     * @param object \{priority, errCancel} => priority of function (highest order first), throw error if already running a function.
+     * @param func any custom function.
+     * @param args the arguments of passed in function.
+     * @returns Error if errCancel and already executing, otherwise result of function.
+     */
+    customPriority({ priority, group, returnIfRunning, errCancel }, func, ...args) {
+        var _a, _b;
+        var _c;
+        const name = (_a = group !== null && group !== void 0 ? group : func.name) !== null && _a !== void 0 ? _a : "anonymous";
+        const actionQueue = ((_b = (_c = this.customPriorityStore)[name]) !== null && _b !== void 0 ? _b : (_c[name] = []));
+        // console.log("custom", group ?? func.name ?? "anonymous", actionQueue, this.isCustomEmpty(name))
+        if (errCancel && actionQueue.length > 1)
+            throw "already executing";
+        if (returnIfRunning && !this.isCustomEmpty(name))
+            return 1;
+        // console.log("running.")
+        return new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+            var _d, _e;
+            const currentlyExecuting = actionQueue.shift();
+            if (currentlyExecuting)
+                this.customCurrentExecuting[(_d = group !== null && group !== void 0 ? group : currentlyExecuting[1].name) !== null && _d !== void 0 ? _d : "anonymous"] = currentlyExecuting;
+            const index = actionQueue.findIndex(([prio]) => priority > prio);
+            actionQueue.splice(index === -1 ? actionQueue.length : index, 0, [
+                priority,
+                () => __awaiter(this, void 0, void 0, function* () {
+                    var _f;
+                    try {
+                        res(yield func(...args));
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                    actionQueue.shift();
+                    yield ((_f = actionQueue[0]) === null || _f === void 0 ? void 0 : _f[1]());
+                }),
+            ]);
+            if (currentlyExecuting) {
+                actionQueue.unshift(currentlyExecuting);
+                this.customCurrentExecuting[(_e = group !== null && group !== void 0 ? group : currentlyExecuting[1].name) !== null && _e !== void 0 ? _e : "anonymous"] = undefined;
+            }
+            else
+                yield actionQueue[0][1]();
+        }));
+    }
+    builtInsPriority({ group, priority, returnIfRunning, errCancel }, func, ...args) {
+        var _a;
+        var _b;
+        const actionQueue = ((_a = (_b = this.builtInsPriorityStore)[group]) !== null && _a !== void 0 ? _a : (_b[group] = []));
+        // console.log("builtin", group, actionQueue)
+        if (errCancel && !this.isBuiltInsEmpty(group))
+            throw "already executing";
+        if (returnIfRunning && !this.isBuiltInsEmpty(group))
+            return 1;
+        return new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+            const currentlyExecuting = actionQueue.shift();
+            if (currentlyExecuting)
+                this.customCurrentExecuting[group] = currentlyExecuting;
+            const index = actionQueue.findIndex(([prio]) => priority > prio);
+            actionQueue.splice(index === -1 ? actionQueue.length : index, 0, [
+                priority,
+                () => __awaiter(this, void 0, void 0, function* () {
+                    var _c;
+                    try {
+                        res(yield func.bind(this.bot)(...args));
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                    actionQueue.shift();
+                    yield ((_c = actionQueue[0]) === null || _c === void 0 ? void 0 : _c[1]());
+                }),
+            ]);
+            if (currentlyExecuting) {
+                actionQueue.unshift(currentlyExecuting);
+                this.builtInCurrentExecuting[group] = undefined;
+            }
+            else
+                yield actionQueue[0][1]();
+        }));
+    }
+}
+exports.UtilFunctions = UtilFunctions;

package/lib/worldRelated/predictiveWorld.d.ts

@@ -0,0 +1,41 @@
+import type { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
+import { Vec3 } from "vec3";
+export declare type Overwrites = {
+    [coord: string]: Block | null;
+};
+/**
+ * A class dedicated to predictive logic.
+ *
+ * Currently, this class can predict explosion damages of crystals using a custom world.
+ */
+export declare class PredictiveWorld {
+    bot: Bot;
+    private blocks;
+    constructor(bot: Bot);
+    raycast(from: Vec3, direction: Vec3, range: number, matcher?: ((block: Block) => boolean) | null): Block | null;
+    /**
+     * this works
+     * @param {Block} block
+     */
+    setBlock(pos: Vec3, block: Block): void;
+    /**
+     * @param {Overwrites} blocks Blocks indexed by position.toString()
+     */
+    setBlocks(blocks: Overwrites): void;
+    /**
+     * @param {Vec3} pos
+     * @returns {Block} Block at position.
+     */
+    getBlock(pos: Vec3): Block | null;
+    removeBlock(pos: Vec3, force: boolean): void;
+    removeBlocks(positions: Vec3[], force: boolean): void;
+    /**
+     * @param playerPos Position of effected entity.
+     * @param explosionPos Position of explosion origin.
+     * @param block bot.block
+     * @returns List of affected blocks that potentially protect the entity.
+     */
+    getExplosionAffectedBlocks(playerPos: Vec3, explosionPos: Vec3): Overwrites;
+    loadExplosionAffectedBlocks(playerPos: Vec3, explosionPos: Vec3): void;
+}