@nxg-org/mineflayer-util-plugin 1.0.0

package/src/predictiveFunctions.ts

@@ -0,0 +1,187 @@
+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";
+
+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) {
+    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);
+    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: number, armorValue: number, toughness: number) {
+    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) {
+    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: number, equipment: Item[]) {
+    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)
+        : 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")){
+            this.armorToughnessKey = "generic.armorToughness";
+            this.armorProtectionKey = "generic.armor";
+        } else {
+            this.armorToughnessKey = "generic.armorToughness";
+            this.armorProtectionKey = "generic.armor";
+        }
+        const effects = md(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(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;
+        return damage * (1 - resistanceLevel / 5);
+    }
+
+    placeBlocks(blocks: Overwrites) {
+        this.world.setBlocks(blocks)
+    }
+
+    removePredictedBlocks(positions: Vec3[], force: boolean = false) {
+        this.world.removeBlocks(positions, force)
+    }
+
+    selfExplosionDamage(sourcePos: Vec3, power: number, 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 as any);
+            damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
+        }
+        return Math.floor(damages);
+    }
+
+    getExplosionDamage(targetEntity: Entity, sourcePos: Vec3, power: number, 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 as any);
+
+            if (targetEntity.type === "player") {
+                damages *= DIFFICULTY_VALUES[this.bot.game.difficulty] * 0.5;
+            }
+        }
+        return Math.floor(damages);
+    }
+}

package/src/utilFunctions.ts

@@ -0,0 +1,152 @@
+import type { Bot, EquipmentDestination, PrioGroups } from "mineflayer";
+import { EntityFunctions } from "./entityFunctions";
+import { FilterFunctions } from "./filterFunctions";
+import { InventoryFunctions } from "./inventoryFunctions";
+import { MovementFunctions } from "./movementFunctions";
+import { promisify } from "util";
+import type { Item } from "prismarine-item";
+import { PredictiveFunctions } from "./predictiveFunctions";
+import { MathFunctions } from "./mathUtil";
+import { CommonSense } from "./commonSense";
+import { WorldFunctions } from "./WorldFunctions";
+
+/**
+ * I don't believe I need any locks, as I'm only going to have one instance of this per bot.
+ * This is added to bot context so multiple instances will exist in memory.
+ * Therefore, I don't need this. https://www.npmjs.com/package/async-lock
+ */
+
+/**
+ * I may add listeners to this class, as halting until an item is equipped may be good.
+ */
+
+/**
+ * I can't inherit from multiple classes. This language sucks.
+ * I'm not using mixins. Fuck you, fuck that.
+ * I'm just going to segregate these functions into separate categories
+ * because once again, fuck you.
+ *
+ */
+
+type priorityStored = [priority: number, executor: () => Promise<void> | void];
+export type BuiltInPriorityOptions = { group: PrioGroups; priority: number; returnIfRunning?: boolean; errCancel?: boolean };
+export type CustomPriorityOptions = { priority: number; group?: PrioGroups; returnIfRunning?: boolean; errCancel?: boolean };
+export class UtilFunctions {
+    public inv: InventoryFunctions;
+    public move: MovementFunctions;
+    public entity: EntityFunctions;
+    public predict: PredictiveFunctions;
+    public filters: FilterFunctions;
+    public math: MathFunctions;
+    public commonSense: CommonSense;
+    public world: WorldFunctions;
+    private builtInsPriorityStore: Partial<{ [funcName: string]: priorityStored[] }>;
+    private customPriorityStore: Partial<{ [funcName: string]: priorityStored[] }>;
+    private builtInCurrentExecuting: { [funcName: string]: priorityStored | undefined };
+    private customCurrentExecuting: { [funcName: string]: priorityStored | undefined };
+    constructor(public bot: Bot) {
+        this.inv = new InventoryFunctions(bot);
+        this.move = new MovementFunctions(bot);
+        this.entity = new EntityFunctions(bot);
+        this.predict = new PredictiveFunctions(bot);
+        this.filters = new FilterFunctions(bot);
+        this.commonSense = new CommonSense(bot);
+        this.world = new WorldFunctions(bot);
+        this.math = new MathFunctions();
+        this.builtInsPriorityStore = {};
+        this.customPriorityStore = {};
+        this.builtInCurrentExecuting = {};
+        this.customCurrentExecuting = {};
+    }
+
+    sleep = promisify(setTimeout);
+
+    isBuiltInsEmpty(name?: string) {
+        if (name) {
+            return !this.builtInsPriorityStore[name]?.length || !this.builtInCurrentExecuting[name];
+        } else {
+            return !Object.values(this.builtInsPriorityStore).length || !Object.values(this.builtInCurrentExecuting).length;
+        }
+    }
+
+    isCustomEmpty(name?: string) {
+        if (name) {
+            return !this.customPriorityStore[name]?.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<K extends (...args: any) => any>(
+        { priority, group, returnIfRunning, errCancel }: CustomPriorityOptions,
+        func: K,
+        ...args: Parameters<K>
+    ): number | Promise<ReturnType<K> | Error> {
+        const name = group ?? func.name ?? "anonymous";
+        const actionQueue = (this.customPriorityStore[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(async (res, rej) => {
+            const currentlyExecuting = actionQueue.shift();
+            if (currentlyExecuting) this.customCurrentExecuting[group ?? currentlyExecuting[1].name ?? "anonymous"] = currentlyExecuting;
+            const index = actionQueue.findIndex(([prio]) => priority > prio);
+            actionQueue.splice(index === -1 ? actionQueue.length : index, 0, [
+                priority,
+                async () => {
+                    try {
+                        res(await func(...(args as any)));
+                    } catch (e) {
+                        rej(e);
+                    }
+                    actionQueue.shift();
+                    await actionQueue[0]?.[1]();
+                },
+            ]);
+            if (currentlyExecuting) {
+                actionQueue.unshift(currentlyExecuting);
+                this.customCurrentExecuting[group ?? currentlyExecuting[1].name ?? "anonymous"] = undefined;
+            } else await actionQueue[0][1]();
+        });
+    }
+
+    builtInsPriority<K extends (...args: any) => any>(
+        { group, priority, returnIfRunning, errCancel }: BuiltInPriorityOptions,
+        func: K,
+        ...args: Parameters<K>
+    ): number | Promise<ReturnType<K> | Error> {
+        const actionQueue = (this.builtInsPriorityStore[group] ??= []);
+        // console.log("builtin", group, actionQueue)
+        if (errCancel && !this.isBuiltInsEmpty(group)) throw "already executing";
+        if (returnIfRunning && !this.isBuiltInsEmpty(group)) return 1;
+        return new Promise(async (res, rej) => {
+            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,
+                async () => {
+                    try {
+                        res(await func.bind(this.bot)(...(args as any)));
+                    } catch (e) {
+                        rej(e);
+                    }
+                    actionQueue.shift();
+                    await actionQueue[0]?.[1]();
+                },
+            ]);
+            if (currentlyExecuting) {
+                actionQueue.unshift(currentlyExecuting);
+                this.builtInCurrentExecuting[group] = undefined;
+            } else await actionQueue[0][1]();
+        });
+    }
+}

package/src/worldRelated/predictiveWorld.ts

@@ -0,0 +1,109 @@
+import type { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
+import { Vec3 } from "vec3";
+import { RaycastIterator } from "./raycastIterator";
+
+export 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 class PredictiveWorld {
+    private blocks: Overwrites = {};
+    constructor(public bot: Bot) {}
+
+    raycast(from: Vec3, direction: Vec3, range: number, matcher: ((block: Block) => boolean) | null = null) {
+        const iter = new RaycastIterator(from, direction, range);
+        let pos = iter.next();
+        while (pos) {
+            const position = new Vec3(pos.x, pos.y, pos.z);
+            const block = this.getBlock(position);
+            if (block && (!matcher || matcher(block))) {
+                const intersect = iter.intersect(block.shapes as any, 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: Vec3, block: Block) {
+        this.blocks[pos.toString()] ??= block;
+    }
+
+    /**
+     * @param {Overwrites} blocks Blocks indexed by position.toString()
+     */
+    setBlocks(blocks: Overwrites) {
+        for (const index in blocks) this.blocks[index] = blocks[index];
+    }
+
+    /**
+     * @param {Vec3} pos
+     * @returns {Block} Block at position.
+     */
+    getBlock(pos: Vec3) {
+        const pblock = this.blocks[pos.toString()];
+        if (pblock !== undefined && pblock !== null) return pblock;
+        return this.bot.blockAt(pos);
+    }
+
+    removeBlock(pos: Vec3, force: boolean) {
+        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: Vec3[], force: boolean) {
+        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: Vec3, explosionPos: Vec3): Overwrites {
+        let blocks: Overwrites = {};
+        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(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: Vec3, explosionPos: Vec3) {
+        this.setBlocks(this.getExplosionAffectedBlocks(playerPos, explosionPos));
+    }
+}

package/src/worldRelated/raycastIterator.ts

@@ -0,0 +1,136 @@
+import type { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
+import { Vec3 } from "vec3";
+
+export enum BlockFace {
+    UNKNOWN = -999,
+    BOTTOM = 0,
+    TOP = 1,
+    NORTH = 2,
+    SOUTH = 3,
+    WEST = 4,
+    EAST = 5,
+}
+
+export 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) {
+        this.block = {
+            x: Math.floor(pos.x),
+            y: Math.floor(pos.y),
+            z: Math.floor(pos.z),
+            face: BlockFace.UNKNOWN,
+        };
+
+        this.blockVec = new Vec3(Math.floor(pos.x), Math.floor(pos.y), Math.floor(pos.z));
+
+        this.pos = pos;
+        this.dir = dir;
+
+        this.invDirX = dir.x === 0 ? Number.MAX_VALUE : 1 / dir.x;
+        this.invDirY = dir.y === 0 ? Number.MAX_VALUE : 1 / dir.y;
+        this.invDirZ = dir.z === 0 ? Number.MAX_VALUE : 1 / dir.z;
+
+        this.stepX = Math.sign(dir.x);
+        this.stepY = Math.sign(dir.y);
+        this.stepZ = Math.sign(dir.z);
+
+        this.tDeltaX = dir.x === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.x);
+        this.tDeltaY = dir.y === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.y);
+        this.tDeltaZ = dir.z === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.z);
+
+        this.tMaxX = dir.x === 0 ? Number.MAX_VALUE : Math.abs((this.block.x + (dir.x > 0 ? 1 : 0) - pos.x) / dir.x);
+        this.tMaxY = dir.y === 0 ? Number.MAX_VALUE : Math.abs((this.block.y + (dir.y > 0 ? 1 : 0) - pos.y) / dir.y);
+        this.tMaxZ = dir.z === 0 ? Number.MAX_VALUE : Math.abs((this.block.z + (dir.z > 0 ? 1 : 0) - pos.z) / dir.z);
+
+        this.maxDistance = maxDistance;
+    }
+
+    // Returns null if none of the shapes is intersected, otherwise returns intersect pos and face
+    // shapes are translated by offset
+    //[x0: number,y0: number,z0: number,x1:number,y1:number,z1:number][]
+    intersect(shapes: [x0: BlockFace, y0: BlockFace, z0: BlockFace, x1: BlockFace, y1: BlockFace, z1: BlockFace][], offset: Vec3) {
+        // Shapes is an array of shapes, each in the form of: [x0, y0, z0, x1, y1, z1]
+        let t = Number.MAX_VALUE;
+        let f = BlockFace.UNKNOWN;
+        const p = this.pos.minus(offset);
+        for (const shape of shapes) {
+            let tmin = (shape[this.invDirX > 0 ? 0 : 3] - p.x) * this.invDirX;
+            let tmax = (shape[this.invDirX > 0 ? 3 : 0] - p.x) * this.invDirX;
+            const tymin = (shape[this.invDirY > 0 ? 1 : 4] - p.y) * this.invDirY;
+            const tymax = (shape[this.invDirY > 0 ? 4 : 1] - p.y) * this.invDirY;
+
+            let face = this.stepX > 0 ? BlockFace.WEST : BlockFace.EAST;
+
+            if (tmin > tymax || tymin > tmax) continue;
+            if (tymin > tmin) {
+                tmin = tymin;
+                face = this.stepY > 0 ? BlockFace.BOTTOM : BlockFace.TOP;
+            }
+            if (tymax < tmax) tmax = tymax;
+
+            const tzmin = (shape[this.invDirZ > 0 ? 2 : 5] - p.z) * this.invDirZ;
+            const tzmax = (shape[this.invDirZ > 0 ? 5 : 2] - p.z) * this.invDirZ;
+
+            if (tmin > tzmax || tzmin > tmax) continue;
+            if (tzmin > tmin) {
+                tmin = tzmin;
+                face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+            if (tzmax < tmax) tmax = tzmax;
+
+            if (tmin < t) {
+                t = tmin;
+                f = face;
+            }
+        }
+        if (t === Number.MAX_VALUE) return null;
+        return { pos: this.pos.plus(this.dir.scaled(t)), face: f };
+    }
+
+    next() {
+        if (Math.min(Math.min(this.tMaxX, this.tMaxY), this.tMaxZ) > this.maxDistance) {
+            return null;
+        }
+
+        if (this.tMaxX < this.tMaxY) {
+            if (this.tMaxX < this.tMaxZ) {
+                this.block.x += this.stepX;
+                this.tMaxX += this.tDeltaX;
+                this.block.face = this.stepX > 0 ? BlockFace.WEST : BlockFace.EAST;
+            } else {
+                this.block.z += this.stepZ;
+                this.tMaxZ += this.tDeltaZ;
+                this.block.face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+        } else {
+            if (this.tMaxY < this.tMaxZ) {
+                this.block.y += this.stepY;
+                this.tMaxY += this.tDeltaY;
+                this.block.face = this.stepY > 0 ? BlockFace.BOTTOM : BlockFace.TOP;
+            } else {
+                this.block.z += this.stepZ;
+                this.tMaxZ += this.tDeltaZ;
+                this.block.face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+        }
+        if (isNaN(this.block.x) || isNaN(this.block.y) || isNaN(this.block.z)) return null;
+        return this.block;
+    }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "rootDir": "src/",
+    "outDir": "lib/",
+    "lib": ["es6", "dom", "es2017"]
+  }
+}