@nxg-org/mineflayer-util-plugin 1.0.0

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

@@ -0,0 +1,172 @@
+"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, 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_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) {
+                const dir = pos.minus(explosionPos);
+                const range = dir.norm();
+                if (world.raycast(explosionPos, dir.normalize(), range) === null) {
+                    exposed++;
+                }
+                sampled++;
+            }
+        }
+    }
+    return exposed / sampled;
+}
+// https://minecraft.fandom.com/wiki/Armor#Damage_protection
+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) {
+    let X = prop.value;
+    for (const mod of prop.modifiers) {
+        if (mod.operation !== 0)
+            continue;
+        X += mod.amount;
+    }
+    let Y = X;
+    for (const mod of prop.modifiers) {
+        if (mod.operation !== 1)
+            continue;
+        Y += X * mod.amount;
+    }
+    for (const mod of prop.modifiers) {
+        if (mod.operation !== 2)
+            continue;
+        Y += Y * mod.amount;
+    }
+    return Y;
+}
+function getDamageWithEnchantments(damage, equipment) {
+    const enchantments = equipment.some((e) => !!e)
+        ? equipment
+            .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,
+};
+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 {
+            this.armorToughnessKey = "generic.armorToughness";
+            this.armorProtectionKey = "generic.armor";
+        }
+        const effects = (0, minecraft_data_1.default)(bot.version).effects;
+        for (const effectId in effects) {
+            const effect = effects[effectId];
+            if (effect.name.includes("resistance")) {
+                this.resistanceIndex = effectId;
+                break;
+            }
+        }
+        this.world = new predictiveWorld_1.PredictiveWorld(bot);
+    }
+    //There's a mistyping in mineflayer. Effect[] is not accurate. You cannot map over it.
+    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) {
+        this.world.setBlocks(blocks);
+    }
+    removePredictedBlocks(positions, force = false) {
+        this.world.removeBlocks(positions, force);
+    }
+    selfExplosionDamage(sourcePos, power, rawDamages = false) {
+        const distance = this.bot.entity.position.distanceTo(sourcePos);
+        const radius = 2 * power;
+        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);
+        // The following modifiers are constant for the input bot.entity and doesnt depend
+        // on the source position, so if the goal is to compare between positions they can be
+        // ignored to save computations
+        if (!rawDamages && this.bot.entity.attributes[this.armorProtectionKey]) {
+            const armor = getAttributeValue(this.bot.entity.attributes[this.armorProtectionKey]);
+            const armorToughness = getAttributeValue(this.bot.entity.attributes[this.armorToughnessKey]);
+            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);
+            damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
+        }
+        return Math.floor(damages);
+    }
+    getExplosionDamage(targetEntity, sourcePos, power, rawDamages = false) {
+        const distance = targetEntity.position.distanceTo(sourcePos);
+        const radius = 2 * power;
+        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);
+        // The following modifiers are constant for the input targetEntity and doesnt depend
+        // on the source position, so if the goal is to compare between positions they can be
+        // ignored to save computations
+        if (!rawDamages && targetEntity.attributes[this.armorProtectionKey]) {
+            const armor = getAttributeValue(targetEntity.attributes[this.armorProtectionKey]);
+            const armorToughness = getAttributeValue(targetEntity.attributes[this.armorToughnessKey]);
+            damages = getDamageAfterAbsorb(damages, armor, armorToughness);
+            damages = getDamageWithEnchantments(damages, targetEntity.equipment);
+            damages = this.getDamageWithEffects(damages, targetEntity.effects);
+            if (targetEntity.type === "player") {
+                damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
+            }
+        }
+        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;
+}

package/lib/worldRelated/predictiveWorld.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictiveWorld = void 0;
+const vec3_1 = require("vec3");
+const raycastIterator_1 = require("./raycastIterator");
+/**
+ * A class dedicated to predictive logic.
+ *
+ * Currently, this class can predict explosion damages of crystals using a custom world.
+ */
+class PredictiveWorld {
+    constructor(bot) {
+        this.bot = bot;
+        this.blocks = {};
+    }
+    raycast(from, direction, range, matcher = null) {
+        const iter = new raycastIterator_1.RaycastIterator(from, direction, range);
+        let pos = iter.next();
+        while (pos) {
+            const position = new vec3_1.Vec3(pos.x, pos.y, pos.z);
+            const block = this.getBlock(position);
+            if (block && (!matcher || matcher(block))) {
+                const intersect = iter.intersect(block.shapes, position);
+                if (intersect) {
+                    //@ts-expect-error 2
+                    block.face = intersect.face;
+                    //@ts-expect-error
+                    block.intersect = intersect.pos;
+                    return block;
+                }
+            }
+            pos = iter.next();
+        }
+        return null;
+    }
+    /**
+     * this works
+     * @param {Block} block
+     */
+    setBlock(pos, block) {
+        var _a;
+        var _b, _c;
+        (_a = (_b = this.blocks)[_c = pos.toString()]) !== null && _a !== void 0 ? _a : (_b[_c] = block);
+    }
+    /**
+     * @param {Overwrites} blocks Blocks indexed by position.toString()
+     */
+    setBlocks(blocks) {
+        for (const index in blocks)
+            this.blocks[index] = blocks[index];
+    }
+    /**
+     * @param {Vec3} pos
+     * @returns {Block} Block at position.
+     */
+    getBlock(pos) {
+        const pblock = this.blocks[pos.toString()];
+        if (pblock !== undefined && pblock !== null)
+            return pblock;
+        return this.bot.blockAt(pos);
+    }
+    removeBlock(pos, force) {
+        if (force) {
+            delete this.blocks[pos.toString()];
+        }
+        else {
+            const realBlock = this.bot.blockAt(pos);
+            if (realBlock)
+                this.blocks[pos.toString()] = realBlock;
+            else
+                delete this.blocks[pos.toString()];
+        }
+    }
+    removeBlocks(positions, force) {
+        positions.forEach((pos) => this.removeBlock(pos, force));
+    }
+    /**
+     * @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, explosionPos) {
+        let blocks = {};
+        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;
+        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) {
+                    const dir = pos.minus(explosionPos);
+                    const range = dir.norm();
+                    const potentialBlock = this.raycast(explosionPos, dir.normalize(), range);
+                    if (potentialBlock !== null)
+                        blocks[potentialBlock.position.toString()] = potentialBlock;
+                }
+            }
+        }
+        return blocks;
+    }
+    loadExplosionAffectedBlocks(playerPos, explosionPos) {
+        this.setBlocks(this.getExplosionAffectedBlocks(playerPos, explosionPos));
+    }
+}
+exports.PredictiveWorld = PredictiveWorld;

package/lib/worldRelated/raycastIterator.d.ts

@@ -0,0 +1,45 @@
+import { Vec3 } from "vec3";
+export declare enum BlockFace {
+    UNKNOWN = -999,
+    BOTTOM = 0,
+    TOP = 1,
+    NORTH = 2,
+    SOUTH = 3,
+    WEST = 4,
+    EAST = 5
+}
+export declare class RaycastIterator {
+    block: {
+        x: number;
+        y: number;
+        z: number;
+        face: number;
+    };
+    blockVec: Vec3;
+    pos: Vec3;
+    dir: Vec3;
+    invDirX: number;
+    invDirY: number;
+    invDirZ: number;
+    stepX: number;
+    stepY: number;
+    stepZ: number;
+    tDeltaX: number;
+    tDeltaY: number;
+    tDeltaZ: number;
+    tMaxX: number;
+    tMaxY: number;
+    tMaxZ: number;
+    maxDistance: number;
+    constructor(pos: Vec3, dir: Vec3, maxDistance: number);
+    intersect(shapes: [x0: BlockFace, y0: BlockFace, z0: BlockFace, x1: BlockFace, y1: BlockFace, z1: BlockFace][], offset: Vec3): {
+        pos: Vec3;
+        face: BlockFace;
+    } | null;
+    next(): {
+        x: number;
+        y: number;
+        z: number;
+        face: number;
+    } | null;
+}