@nxg-org/mineflayer-ender 1.0.1

package/lib/calc/aabbUtil.d.ts

@@ -0,0 +1,10 @@
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
+import type { Block } from "prismarine-block";
+import type { Vec3 } from "vec3";
+export declare function getEntityAABB(entity: {
+    position: Vec3;
+    height: number;
+    width?: number;
+}): AABB;
+export declare function getBlockAABB(block: Block, height?: number): AABB;
+export declare function getBlockPosAABB(block: Vec3, height?: number): AABB;

package/lib/calc/aabbUtil.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockPosAABB = exports.getBlockAABB = exports.getEntityAABB = void 0;
+const mineflayer_util_plugin_1 = require("@nxg-org/mineflayer-util-plugin");
+function 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 mineflayer_util_plugin_1.AABB(-w, 0, -w, w, entity.height, w).offset(x, y, z);
+}
+exports.getEntityAABB = getEntityAABB;
+function getBlockAABB(block, height = 1) {
+    const { x, y, z } = block.position;
+    return new mineflayer_util_plugin_1.AABB(x, y, z, x + 1, y + height, z + 1);
+}
+exports.getBlockAABB = getBlockAABB;
+function getBlockPosAABB(block, height = 1) {
+    const { x, y, z } = block.floored();
+    return new mineflayer_util_plugin_1.AABB(x, y, z, x + 1, y + height, z + 1);
+}
+exports.getBlockPosAABB = getBlockPosAABB;

package/lib/calc/constants.d.ts

@@ -0,0 +1,26 @@
+declare type ProjectileInfo = {
+    v0: number;
+    g: number;
+};
+declare type ProjectileInfos = {
+    [name: string]: ProjectileInfo;
+};
+declare type ProjectileGravity = {
+    [name: string]: number;
+};
+export declare const trajectoryInfo: ProjectileInfos;
+export declare const projectileGravity: ProjectileGravity;
+export declare const airResistance: {
+    y: number;
+    h: number;
+};
+export declare enum BlockFace {
+    UNKNOWN = -999,
+    BOTTOM = 0,
+    TOP = 1,
+    NORTH = 2,
+    SOUTH = 3,
+    WEST = 4,
+    EAST = 5
+}
+export {};

package/lib/calc/constants.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockFace = exports.airResistance = exports.projectileGravity = exports.trajectoryInfo = void 0;
+exports.trajectoryInfo = {
+    bow: { v0: 3, g: 0.05 },
+    crossbow: { v0: 3.15, g: 0.05 },
+    crossbow_firework: { v0: 1.6, g: 0.00 },
+    trident: { v0: 2.5, g: 0.05 },
+    snowball: { v0: 1.5, g: 0.04 },
+    egg: { v0: 1.5, g: 0.04 },
+    ender_pearl: { v0: 1.5, g: 0.0375 },
+    splash_potion: { v0: 0.4, g: 0.03 },
+};
+exports.projectileGravity = {
+    arrow: 0.05,
+    trident: 0.05,
+    egg: 0.04,
+    snowball: 0.04,
+    ender_pearl: 0.04,
+    splash_potion: 0.03,
+    firework_rocket: 0.00,
+};
+exports.airResistance = {
+    y: 0.01,
+    h: 0.01
+};
+var BlockFace;
+(function (BlockFace) {
+    BlockFace[BlockFace["UNKNOWN"] = -999] = "UNKNOWN";
+    BlockFace[BlockFace["BOTTOM"] = 0] = "BOTTOM";
+    BlockFace[BlockFace["TOP"] = 1] = "TOP";
+    BlockFace[BlockFace["NORTH"] = 2] = "NORTH";
+    BlockFace[BlockFace["SOUTH"] = 3] = "SOUTH";
+    BlockFace[BlockFace["WEST"] = 4] = "WEST";
+    BlockFace[BlockFace["EAST"] = 5] = "EAST";
+})(BlockFace = exports.BlockFace || (exports.BlockFace = {}));

package/lib/calc/mathUtilts.d.ts

@@ -0,0 +1,48 @@
+import { Vec3 } from "vec3";
+export declare const toNotchianYaw: (yaw: number) => number;
+export declare const toNotchianPitch: (pitch: number) => number;
+export declare const fromNotchianYawByte: (yaw: number) => number;
+export declare const fromNotchianPitchByte: (pitch: number) => number;
+export declare function euclideanMod(numerator: number, denominator: number): number;
+export declare function toRadians(degrees: number): number;
+export declare function toDegrees(radians: number): number;
+export declare function fromNotchianYaw(yaw: number): number;
+export declare function fromNotchianPitch(pitch: number): number;
+export declare function fromNotchVelocity(vel: Vec3): Vec3;
+export declare function pointToYawAndPitch(org: Vec3, point: Vec3): {
+    yaw: number;
+    pitch: number;
+};
+export declare function dirToYawAndPitch(dir: Vec3): {
+    yaw: number;
+    pitch: number;
+};
+export declare function getTargetDistance(origin: Vec3, destination: Vec3): {
+    distance: number;
+    hDistance: number;
+    yDistance: number;
+};
+export declare function getTargetYaw(origin: Vec3, destination: Vec3): number;
+export declare function getPremonition(startPosition: Vec3, targetPosition: Vec3, speed: Vec3, totalTicks: number): {
+    distances: {
+        distance: number;
+        hDistance: number;
+        yDistance: number;
+    };
+    newTarget: Vec3;
+};
+export declare function degreesToRadians(degrees: number): number;
+export declare function radiansToDegrees(radians: number): number;
+export declare function getVox(Vo: number, Alfa: number, Resistance?: number): number;
+export declare function getVoy(Vo: number, Alfa: number, Resistance?: number): number;
+export declare function getVo(Vox: number, Voy: number, G: number): number;
+export declare function getGrades(Vo: number, Voy: number, Gravity: number): number;
+export declare function vectorMagnitude(vec: Vec3): number;
+export declare function VoToVox(vec: Vec3, mag?: number): number;
+export declare function yawPitchAndSpeedToDir(yaw: number, pitch: number, speed: number): Vec3;
+export declare function notchianVel(vec: Vec3, Vo?: number, Vox?: number): {
+    Vo: number;
+    Vox: number;
+    vel: Vec3;
+};
+export declare function applyVec3Gravity(currentVel: Vec3, gravity: Vec3): Vec3;

package/lib/calc/mathUtilts.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyVec3Gravity = exports.notchianVel = exports.yawPitchAndSpeedToDir = exports.VoToVox = exports.vectorMagnitude = exports.getGrades = exports.getVo = exports.getVoy = exports.getVox = exports.radiansToDegrees = exports.degreesToRadians = exports.getPremonition = exports.getTargetYaw = exports.getTargetDistance = exports.dirToYawAndPitch = exports.pointToYawAndPitch = exports.fromNotchVelocity = exports.fromNotchianPitch = exports.fromNotchianYaw = exports.toDegrees = exports.toRadians = exports.euclideanMod = exports.fromNotchianPitchByte = exports.fromNotchianYawByte = exports.toNotchianPitch = exports.toNotchianYaw = void 0;
+const vec3_1 = require("vec3");
+const PI = Math.PI;
+const PI_2 = Math.PI * 2;
+const TO_RAD = PI / 180;
+const TO_DEG = 1 / TO_RAD;
+const FROM_NOTCH_BYTE = 360 / 256;
+// From wiki.vg: Velocity is believed to be in units of 1/8000 of a block per server tick (50ms)
+const FROM_NOTCH_VEL = 1 / 8000;
+const toNotchianYaw = (yaw) => toDegrees(PI - yaw);
+exports.toNotchianYaw = toNotchianYaw;
+const toNotchianPitch = (pitch) => toDegrees(-pitch);
+exports.toNotchianPitch = toNotchianPitch;
+const fromNotchianYawByte = (yaw) => fromNotchianYaw(yaw * FROM_NOTCH_BYTE);
+exports.fromNotchianYawByte = fromNotchianYawByte;
+const fromNotchianPitchByte = (pitch) => fromNotchianPitch(pitch * FROM_NOTCH_BYTE);
+exports.fromNotchianPitchByte = fromNotchianPitchByte;
+function euclideanMod(numerator, denominator) {
+    const result = numerator % denominator;
+    return result < 0 ? result + denominator : result;
+}
+exports.euclideanMod = euclideanMod;
+function toRadians(degrees) {
+    return TO_RAD * degrees;
+}
+exports.toRadians = toRadians;
+function toDegrees(radians) {
+    return TO_DEG * radians;
+}
+exports.toDegrees = toDegrees;
+function fromNotchianYaw(yaw) {
+    return euclideanMod(PI - toRadians(yaw), PI_2);
+}
+exports.fromNotchianYaw = fromNotchianYaw;
+function fromNotchianPitch(pitch) {
+    return euclideanMod(toRadians(-pitch) + PI, PI_2) - PI;
+}
+exports.fromNotchianPitch = fromNotchianPitch;
+function fromNotchVelocity(vel) {
+    return new vec3_1.Vec3(vel.x * FROM_NOTCH_VEL, vel.y * FROM_NOTCH_VEL, vel.z * FROM_NOTCH_VEL);
+}
+exports.fromNotchVelocity = fromNotchVelocity;
+function pointToYawAndPitch(org, point) {
+    const delta = point.minus(org);
+    return dirToYawAndPitch(delta);
+}
+exports.pointToYawAndPitch = pointToYawAndPitch;
+function dirToYawAndPitch(dir) {
+    const yaw = Math.atan2(dir.x, dir.z) + Math.PI;
+    const groundDistance = Math.sqrt(dir.x * dir.x + dir.z * dir.z);
+    const pitch = Math.atan2(dir.y, groundDistance);
+    return { yaw: yaw, pitch: pitch };
+}
+exports.dirToYawAndPitch = dirToYawAndPitch;
+function getTargetDistance(origin, destination) {
+    const xDistance = Math.pow(origin.x - destination.x, 2);
+    const zDistance = Math.pow(origin.z - destination.z, 2);
+    const hDistance = Math.sqrt(xDistance + zDistance);
+    const yDistance = destination.y - origin.y;
+    const distance = Math.sqrt(Math.pow(yDistance, 2) + xDistance + zDistance);
+    return {
+        distance,
+        hDistance,
+        yDistance,
+    };
+}
+exports.getTargetDistance = getTargetDistance;
+function getTargetYaw(origin, destination) {
+    const xDistance = destination.x - origin.x;
+    const zDistance = destination.z - origin.z;
+    const yaw = Math.atan2(xDistance, zDistance) + Math.PI;
+    return yaw;
+}
+exports.getTargetYaw = getTargetYaw;
+function getPremonition(startPosition, targetPosition, speed, totalTicks) {
+    totalTicks = totalTicks + Math.ceil(totalTicks / 10);
+    const newTarget = targetPosition;
+    for (let i = 0; i < totalTicks; i++) {
+        newTarget.add(speed);
+    }
+    const distances = getTargetDistance(startPosition, newTarget);
+    return {
+        distances,
+        newTarget,
+    };
+}
+exports.getPremonition = getPremonition;
+function degreesToRadians(degrees) {
+    const pi = Math.PI;
+    return degrees * (pi / 180);
+}
+exports.degreesToRadians = degreesToRadians;
+function radiansToDegrees(radians) {
+    const pi = Math.PI;
+    return radians * (180 / pi);
+}
+exports.radiansToDegrees = radiansToDegrees;
+function getVox(Vo, Alfa, Resistance = 0) {
+    return Vo * Math.cos(Alfa) - Resistance;
+}
+exports.getVox = getVox;
+function getVoy(Vo, Alfa, Resistance = 0) {
+    return Vo * Math.sin(Alfa) - Resistance;
+}
+exports.getVoy = getVoy;
+function getVo(Vox, Voy, G) {
+    return Math.sqrt(Math.pow(Vox, 2) + Math.pow(Voy - G, 2)); // New Total Velocity - Gravity
+}
+exports.getVo = getVo;
+function getGrades(Vo, Voy, Gravity) {
+    return radiansToDegrees(Math.asin((Voy - Gravity) / Vo));
+}
+exports.getGrades = getGrades;
+function vectorMagnitude(vec) {
+    return Math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
+}
+exports.vectorMagnitude = vectorMagnitude;
+function VoToVox(vec, mag) {
+    return mag ? Math.sqrt(mag * mag - vec.y * vec.y) : Math.sqrt(Math.pow(vectorMagnitude(vec), 2) - vec.y * vec.y);
+}
+exports.VoToVox = VoToVox;
+//Scuffed.
+function yawPitchAndSpeedToDir(yaw, pitch, speed) {
+    const thetaY = Math.PI + yaw;
+    const thetaP = pitch;
+    const x = speed * Math.sin(thetaY);
+    const y = speed * Math.sin(thetaP);
+    const z = speed * Math.cos(thetaY);
+    const VxMag = Math.sqrt(x * x + z * z);
+    const VxRatio = Math.sqrt(VxMag * VxMag - y * y);
+    const allRatio = VxRatio / VxMag;
+    return new vec3_1.Vec3(x * allRatio, y, z * allRatio);
+}
+exports.yawPitchAndSpeedToDir = yawPitchAndSpeedToDir;
+// TODO: make it not throw NaN.
+function notchianVel(vec, Vo, Vox) {
+    if (Vo && Vox) {
+        return { Vo, Vox, vel: new vec3_1.Vec3(vec.x * (Vox / Vo), vec.y, vec.z * (Vox / Vo)) };
+    }
+    else if (Vo) {
+        const Vox = VoToVox(vec, Vo);
+        return { Vo, Vox, vel: new vec3_1.Vec3(vec.x * (Vox / Vo), vec.y, vec.z * (Vox / Vo)) };
+    }
+    else {
+        // console.log(vec)
+        const Vo = vectorMagnitude(vec);
+        const Vox = VoToVox(vec);
+        // console.log(Math.pow(Vo, 2), vec.y * vec.y)
+        return { Vo, Vox, vel: new vec3_1.Vec3(vec.x * (Vox / Vo), vec.y, vec.z * (Vox / Vo)) };
+    }
+}
+exports.notchianVel = notchianVel;
+function applyVec3Gravity(currentVel, gravity) {
+    return currentVel.plus(gravity);
+}
+exports.applyVec3Gravity = applyVec3Gravity;

package/lib/enderPlanner.d.ts

@@ -0,0 +1,41 @@
+import { Bot } from "mineflayer";
+import { Vec3 } from "vec3";
+import { BasicShotInfo } from "./types";
+import { Block } from "prismarine-block";
+declare type CheckShotInfo = {
+    yaw: number;
+    pitch: number;
+    ticks: number;
+    shift?: boolean;
+};
+export declare type CheckedShot = {
+    hit: boolean;
+    yaw: number;
+    pitch: number;
+    ticks: number;
+    shotInfo: BasicShotInfo | null;
+};
+export declare class EnderShotPlanner {
+    private bot;
+    private intercepter;
+    constructor(bot: Bot);
+    get originVel(): Vec3;
+    private isShotValid;
+    /**
+     * Better optimization. Still about 5x more expensive than hawkeye (no clue what I did) but its more accurate so whatever.
+     *
+     * Note: The increased cost comes from the increased checks made (1440 vs 100). This will be fixed.
+     *
+     * @param target
+     * @param avgSpeed
+     * @param pitch
+     * @returns {CheckedShot} the shot.
+     */
+    shotToBlock(target: Block | Vec3, face?: number, avgSpeed?: Vec3, pitch?: number): CheckedShot | null;
+    private shiftTargetPositions;
+    checkForBlockIntercepts(target: Block | Vec3, ...shots: CheckShotInfo[]): CheckedShot;
+    getNextShot(target: Block, yaw: number, face?: number, minPitch?: number): CheckShotInfo;
+    getAlternativeYawShots(target: Block | Vec3, face?: number, ...shots: CheckShotInfo[]): CheckedShot;
+    getAllPossibleShots(target: Block | Vec3, yaw: number, face?: number): CheckShotInfo[];
+}
+export {};

package/lib/enderPlanner.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnderShotPlanner = void 0;
+const enderShotFactory_1 = require("./enderShotFactory");
+const mathUtilts_1 = require("./calc/mathUtilts");
+const vec3_1 = require("vec3");
+const mineflayer_util_plugin_1 = require("@nxg-org/mineflayer-util-plugin");
+const aabbUtil_1 = require("./calc/aabbUtil");
+const emptyVec = new vec3_1.Vec3(0, 0, 0);
+const dv = Math.PI / 2880;
+const PIOver2 = Math.PI / 2;
+const PIOver3 = Math.PI / 3;
+class EnderShotPlanner {
+    constructor(bot) {
+        this.bot = bot;
+        this.intercepter = new mineflayer_util_plugin_1.InterceptFunctions(bot);
+    }
+    get originVel() {
+        return this.bot.entity.velocity;
+    }
+    isShotValid(shotInfo1, target, pitch, face) {
+        if (!(target instanceof vec3_1.Vec3)) {
+            target = target.position;
+        }
+        let shotInfo = shotInfo1.shotInfo;
+        if (!shotInfo)
+            shotInfo = shotInfo1;
+        //@ts-expect-error
+        if (shotInfo.shotInfo)
+            shotInfo = shotInfo.shotInfo;
+        if (!shotInfo)
+            return false;
+        if (shotInfo.block && pitch > PIOver3) {
+            // console.log("final check", pitch, shotInfo.landingDistance, target, shotInfo.block.position, (!face || face === shotInfo.blockFace));
+            return shotInfo.landingDistance <= 1 && shotInfo.block.position.y === target.y && (!face || face === shotInfo.blockFace);
+        }
+        else if (shotInfo.block) {
+            // console.log("final check", pitch, shotInfo.landingDistance === 0, (!face || face === shotInfo.blockFace));
+            return shotInfo.landingDistance <= 1 && shotInfo.block.position.y === target.y && (!face || face === shotInfo.blockFace);
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Better optimization. Still about 5x more expensive than hawkeye (no clue what I did) but its more accurate so whatever.
+     *
+     * Note: The increased cost comes from the increased checks made (1440 vs 100). This will be fixed.
+     *
+     * @param target
+     * @param avgSpeed
+     * @param pitch
+     * @returns {CheckedShot} the shot.
+     */
+    shotToBlock(target, face, avgSpeed = emptyVec, pitch = -PIOver2) {
+        if (target instanceof vec3_1.Vec3) {
+            const tmp = this.bot.blockAt(target);
+            if (!tmp)
+                throw "couldn't find block.";
+            target = tmp;
+        }
+        const yaw = (0, mathUtilts_1.getTargetYaw)(this.bot.entity.position, target.position);
+        while (pitch < PIOver2) {
+            const initInfo = this.getNextShot(target, yaw, face, pitch);
+            if (isNaN(initInfo.pitch)) {
+                console.log("shit...");
+                return null;
+            }
+            pitch = initInfo.pitch;
+            // if (avgSpeed.equals(emptyVec)) {
+            const correctShot = this.checkForBlockIntercepts(target, initInfo);
+            if (this.isShotValid(correctShot, target.position, pitch))
+                return correctShot;
+            const yawShot = this.getAlternativeYawShots(target, face, initInfo);
+            if (this.isShotValid(yawShot, target.position, pitch))
+                return yawShot;
+            // } else {
+            //     const newInfo = this.shiftTargetPositions(target.position, avgSpeed,face, initInfo);
+            //     for (const i of newInfo) {
+            //         const correctShot = this.checkForBlockIntercepts(i.target, ...i.info);
+            //         if (!correctShot.shotInfo) continue;
+            //         if (this.isShotValid(correctShot, i.target, pitch)) return correctShot;
+            //         const yawShot = this.getAlternativeYawShots(i.target, face,initInfo);
+            //         if (this.isShotValid(yawShot, i.target, pitch)) return yawShot;
+            //     }
+            // }
+        }
+        return null;
+    }
+    shiftTargetPositions(target, avgSpeed, face, ...shotInfo) {
+        const newInfo = shotInfo.map((i) => (i.shift ? target.clone().add(avgSpeed.clone().scale(Math.ceil(i.ticks) + 5)) : target)); //weird monkey patch.
+        const allInfo = [];
+        for (const position of newInfo) {
+            const yaw = (0, mathUtilts_1.getTargetYaw)(this.bot.entity.position, position);
+            const res = this.getAllPossibleShots(target, yaw, face);
+            const info = res.map((i) => {
+                return { yaw, pitch: i.pitch, ticks: i.ticks };
+            });
+            allInfo.push({ target: target, info });
+        }
+        return allInfo;
+    }
+    checkForBlockIntercepts(target, ...shots) {
+        if (!(target instanceof vec3_1.Vec3))
+            target = target.position;
+        for (const { pitch, ticks, yaw } of shots) {
+            const initShot = enderShotFactory_1.EnderShotFactory.fromPlayer({ position: this.bot.entity.position, yaw, pitch, velocity: this.originVel, }, this.bot, this.intercepter);
+            const shot = initShot.calcToBlock(target, true, true);
+            if (this.isShotValid(shot, target, pitch))
+                return { hit: true, yaw, pitch, ticks, shotInfo: shot };
+        }
+        return { hit: false, yaw: NaN, pitch: NaN, ticks: NaN, shotInfo: null };
+    }
+    getNextShot(target, yaw, face, minPitch = -PIOver2) {
+        let isHitting = false;
+        let initHit = false;
+        let shiftPos = true;
+        let hittingData = [];
+        for (let pitch = minPitch + dv; pitch < PIOver2; pitch += dv) {
+            const initShot = enderShotFactory_1.EnderShotFactory.fromPlayer({ position: this.bot.entity.position, yaw, pitch, velocity: this.originVel }, this.bot, this.intercepter);
+            const shot = initShot.calcToBlock(target);
+            // console.log(face, shot.blockFace, pitch.toFixed(4), shot.landingDistance)
+            // console.log(pitch.toFixed(4), shot.landingDistance, shot.totalTicks, shot.blockFace)
+            if (!this.isShotValid(shot, target, pitch)) {
+                isHitting = false;
+                if (hittingData.length !== 0) {
+                    const avgPitch = hittingData.map((e) => e.pitch).reduce((a, b) => a + b) / hittingData.length; //monkeypatch to hit feet.
+                    const avgTicks = hittingData.map((e) => e.ticks).reduce((a, b) => a + b) / hittingData.length;
+                    return { yaw, pitch: avgPitch, ticks: Math.floor(avgTicks), shift: shiftPos };
+                }
+                else if (pitch > PIOver3 && shot.landingDistance <= 1 && (!face || face === shot.blockFace)) {
+                    shiftPos = false;
+                    hittingData.push({ pitch, ticks: shot.totalTicks });
+                }
+                continue;
+            }
+            initHit = hittingData.length === 0;
+            hittingData.push({ pitch, ticks: shot.totalTicks });
+            if (initHit)
+                isHitting = true;
+            if (isHitting)
+                continue;
+        }
+        return { yaw: NaN, pitch: NaN, ticks: NaN };
+    }
+    getAlternativeYawShots(target, face, ...shots) {
+        if (!(target instanceof vec3_1.Vec3))
+            target = target.position;
+        for (const { pitch, yaw: orgYaw } of shots) {
+            const yaws = (0, aabbUtil_1.getBlockPosAABB)(target)
+                .toVertices()
+                .map((p) => (0, mathUtilts_1.getTargetYaw)(this.bot.entity.position, p))
+                .sort((a, b) => orgYaw - Math.abs(a) - (orgYaw - Math.abs(b)));
+            let inbetween = [yaws.pop(), yaws.pop()];
+            inbetween = inbetween.map((y) => y + Math.sign(orgYaw - y) * 0.02);
+            for (const yaw of inbetween) {
+                const initShot = enderShotFactory_1.EnderShotFactory.fromPlayer({ position: this.bot.entity.position, yaw, pitch, velocity: this.originVel, }, this.bot, this.intercepter);
+                const shot = initShot.calcToBlock(target, true);
+                if (this.isShotValid(shot, target, pitch)) {
+                    return { hit: true, yaw, pitch, ticks: shot.totalTicks, shotInfo: shot };
+                }
+            }
+        }
+        return { hit: false, yaw: NaN, pitch: NaN, ticks: NaN, shotInfo: null };
+    }
+    //TODO: This is too expensive. Will aim at offset off foot instead of calc'ing all hits and averaging.
+    getAllPossibleShots(target, yaw, face) {
+        if (target instanceof vec3_1.Vec3) {
+            const tmp = this.bot.blockAt(target);
+            if (!tmp)
+                throw "couldn't find block.";
+            target = tmp;
+        }
+        let possibleShotData = [];
+        let isHitting = false;
+        let initHit = false;
+        let shiftPos = true;
+        let hittingData = [];
+        for (let pitch = -PIOver2; pitch < PIOver2; pitch += dv) {
+            const initShot = enderShotFactory_1.EnderShotFactory.fromPlayer({ position: this.bot.entity.position, yaw, pitch, velocity: this.originVel }, this.bot, this.intercepter);
+            const shot = initShot.calcToBlock(target, false);
+            if (shot.block !== target || shot.blockFace !== face) {
+                isHitting = false;
+                if (hittingData.length !== 0) {
+                    const avgPitch = hittingData.map((e) => e.pitch).reduce((a, b) => a + b) / hittingData.length; //monkeypatch to hit feet.
+                    const avgTicks = hittingData.map((e) => e.ticks).reduce((a, b) => a + b) / hittingData.length;
+                    possibleShotData.push({ yaw, pitch: avgPitch, ticks: Math.floor(avgTicks), shift: shiftPos });
+                    hittingData = [];
+                    shiftPos = true;
+                }
+                else if (pitch > PIOver3 && shot.landingDistance <= 1 && (!face || face === shot.blockFace)) {
+                    // console.log(pitch, shot.nearestDistance)
+                    shiftPos = false;
+                    hittingData.push({ pitch, ticks: shot.totalTicks });
+                    // possibleShotData.push({ yaw, pitch, ticks: shot.totalTicks, shift: true });
+                }
+                continue;
+            }
+            initHit = hittingData.length === 0;
+            hittingData.push({ pitch, ticks: shot.totalTicks });
+            if (initHit)
+                isHitting = true;
+            if (isHitting)
+                continue;
+        }
+        // console.log(possibleShotData)
+        return possibleShotData;
+    }
+}
+exports.EnderShotPlanner = EnderShotPlanner;

package/lib/enderShot.d.ts

@@ -0,0 +1,43 @@
+import { Vec3 } from "vec3";
+import type { Bot } from "mineflayer";
+import { Block } from "prismarine-block";
+import { InterceptFunctions } from "@nxg-org/mineflayer-util-plugin";
+import { BasicShotInfo, ProjectileMotion } from "./types";
+/**
+ * TODO: Change hit detection from AABB -> Ray to AABB -> Moving AABB of 0.5h, 0.5w.
+ * ! We are "missing" shots due to this miscalculation.
+ * * DONE! WOOOOOOOOOO
+ *
+ * TODO: Completely rewrite arrow trajectory calculation. Currently using assumptions, can be much better.
+ * ! It is very fast; I will have to optimize even more.
+ * * DONE! WOOOOOOOOOO
+ *
+ * TODO: Work on caching arrow trajectories. This will speed up repeated look-ups and encourage reuse of classes to save RAM/CPU.
+ *
+ */
+/**
+ * uses:
+ * (a) calculate shot based off current entities yaw and target
+ * (b) calculate correct yaw and target
+ * (c) better block detection
+ * (d) velocity checks
+ */
+/**
+ * Purposely left off prediction.
+ * You can handle that outside of the Shot class.
+ */
+export declare class EnderShot {
+    readonly initialPos: Vec3;
+    readonly initialVel: Vec3;
+    readonly initialYaw: number;
+    readonly initialPitch: number;
+    readonly gravity: number;
+    private points;
+    private pointVelocities;
+    private blockHit;
+    private bot;
+    interceptCalcs: InterceptFunctions;
+    blockCheck: boolean;
+    constructor(originVel: Vec3, { position: pPos, velocity: pVel, gravity }: Required<ProjectileMotion>, bot: Bot, interceptCalcs?: InterceptFunctions);
+    calcToBlock(target: Block | Vec3, blockChecking?: boolean, log?: boolean): BasicShotInfo;
+}

package/lib/enderShot.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnderShot = void 0;
+const vec3_1 = require("vec3");
+const mathUtilts_1 = require("./calc/mathUtilts");
+const constants_1 = require("./calc/constants");
+const aabbUtil_1 = require("./calc/aabbUtil");
+const mineflayer_util_plugin_1 = require("@nxg-org/mineflayer-util-plugin");
+const emptyVec = new vec3_1.Vec3(0, 0, 0);
+/**
+ * TODO: Change hit detection from AABB -> Ray to AABB -> Moving AABB of 0.5h, 0.5w.
+ * ! We are "missing" shots due to this miscalculation.
+ * * DONE! WOOOOOOOOOO
+ *
+ * TODO: Completely rewrite arrow trajectory calculation. Currently using assumptions, can be much better.
+ * ! It is very fast; I will have to optimize even more.
+ * * DONE! WOOOOOOOOOO
+ *
+ * TODO: Work on caching arrow trajectories. This will speed up repeated look-ups and encourage reuse of classes to save RAM/CPU.
+ *
+ */
+/**
+ * uses:
+ * (a) calculate shot based off current entities yaw and target
+ * (b) calculate correct yaw and target
+ * (c) better block detection
+ * (d) velocity checks
+ */
+/**
+ * Purposely left off prediction.
+ * You can handle that outside of the Shot class.
+ */
+class EnderShot {
+    constructor(originVel, { position: pPos, velocity: pVel, gravity }, bot, interceptCalcs) {
+        this.blockHit = false;
+        this.blockCheck = false;
+        const { yaw, pitch } = (0, mathUtilts_1.dirToYawAndPitch)(pVel);
+        this.initialPos = pPos.clone();
+        this.initialVel = pVel.clone().add(originVel);
+        this.gravity = gravity;
+        this.initialYaw = yaw;
+        this.initialPitch = pitch;
+        this.points = [];
+        this.pointVelocities = [];
+        this.bot = bot;
+        this.interceptCalcs = interceptCalcs !== null && interceptCalcs !== void 0 ? interceptCalcs : new mineflayer_util_plugin_1.InterceptFunctions(bot);
+    }
+    calcToBlock(target, blockChecking = true, log = false) {
+        const targetPos = target instanceof vec3_1.Vec3 ? target : target.position;
+        const targetAABB = (0, aabbUtil_1.getBlockPosAABB)(targetPos);
+        let currentVelocity = this.initialVel.clone();
+        // if (log) console.log(currentVelocity)
+        let currentPosition = this.initialPos.clone();
+        let nextPosition = currentPosition.clone().add(currentVelocity);
+        let nearestDistance = targetAABB.distanceTo(this.initialPos); // initial distance.
+        let currentDistance = nearestDistance;
+        let landingDistance = 100000; //todo, make cleaner.
+        let blockInfo;
+        let closestPoint = null;
+        let blockHit = null;
+        let blockHitFace;
+        let totalTicks = 0;
+        const gravity = this.gravity; //this.gravity * airResistance.y;
+        let offsetX;
+        let offsetY;
+        let offsetZ;
+        while (totalTicks < 300) {
+            totalTicks++;
+            offsetX = -currentVelocity.x * constants_1.airResistance.h;
+            offsetY = -currentVelocity.y * constants_1.airResistance.y - gravity;
+            offsetZ = -currentVelocity.z * constants_1.airResistance.h;
+            const posDistance = targetPos.distanceTo(currentPosition);
+            if (nearestDistance > posDistance) {
+                nearestDistance = posDistance;
+                closestPoint = currentPosition.clone();
+            }
+            if (blockChecking) {
+                blockInfo = this.interceptCalcs.check(currentPosition, nextPosition);
+                if (blockInfo.block) {
+                    blockHit = blockInfo.block;
+                    blockHitFace = blockInfo.iterations[0].face; //todo, make cleaner.
+                    landingDistance = targetPos.distanceTo(blockInfo.block.position); //todo: get block interception point.
+                    break;
+                }
+            }
+            const intersection = targetAABB.intersectsSegment(currentPosition, nextPosition);
+            if (intersection) {
+                blockHit = this.bot.blockAt(intersection);
+                closestPoint = intersection.clone();
+                nearestDistance = 0;
+                landingDistance = 0;
+                break;
+            }
+            // console.log(currentPosition, nextPosition, totalTicks)
+            currentPosition.add(currentVelocity);
+            currentVelocity.translate(offsetX, offsetY, offsetZ);
+            nextPosition.add(currentVelocity);
+        }
+        return {
+            landingDistance,
+            block: blockHit,
+            blockFace: blockHitFace,
+            closestPoint,
+            totalTicks
+        };
+    }
+}
+exports.EnderShot = EnderShot;

package/lib/enderShotFactory.d.ts

@@ -0,0 +1,9 @@
+import { InterceptFunctions } from "@nxg-org/mineflayer-util-plugin";
+import { Bot } from "mineflayer";
+import { EnderShot } from "./enderShot";
+import { ProjectileMotion, ShotEntity } from "./types";
+export declare class EnderShotFactory {
+    static fromPlayer({ position, yaw, pitch, velocity, heldItem }: ShotEntity, bot: Bot, interceptCalcs?: InterceptFunctions): EnderShot;
+    static withoutGravity({ position, velocity }: ProjectileMotion, bot: Bot, interceptCalcs?: InterceptFunctions): EnderShot;
+    static customGravity({ position, velocity }: ProjectileMotion, gravity: number, bot: Bot, interceptCalcs?: InterceptFunctions): EnderShot;
+}

package/lib/enderShotFactory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnderShotFactory = void 0;
+const vec3_1 = require("vec3");
+const constants_1 = require("./calc/constants");
+const mathUtilts_1 = require("./calc/mathUtilts");
+const enderShot_1 = require("./enderShot");
+const emptyVec = new vec3_1.Vec3(0, 0, 0);
+class EnderShotFactory {
+    static fromPlayer({ position, yaw, pitch, velocity, heldItem }, bot, interceptCalcs) {
+        const info = constants_1.trajectoryInfo["ender_pearl"];
+        const projVel = (0, mathUtilts_1.yawPitchAndSpeedToDir)(yaw, pitch, info.v0);
+        return new enderShot_1.EnderShot(velocity, { position: position.offset(0, 1.62, 0), velocity: projVel, gravity: info.g }, bot, interceptCalcs);
+    }
+    static withoutGravity({ position, velocity }, bot, interceptCalcs) {
+        return new enderShot_1.EnderShot(emptyVec, { position, velocity, gravity: 0.00 }, bot, interceptCalcs);
+    }
+    static customGravity({ position, velocity }, gravity, bot, interceptCalcs) {
+        return new enderShot_1.EnderShot(emptyVec, { position, velocity, gravity }, bot, interceptCalcs);
+    }
+}
+exports.EnderShotFactory = EnderShotFactory;

package/lib/example.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/example.js

@@ -0,0 +1,60 @@
+"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 };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+const mineflayer_1 = require("mineflayer");
+const index_1 = __importDefault(require("./index"));
+let target = null;
+let targetBlock = null;
+const bot = (0, mineflayer_1.createBot)({
+    username: "ender-testing",
+    host: (_a = process.argv[2]) !== null && _a !== void 0 ? _a : "localhost",
+    port: (_b = Number(process.argv[3])) !== null && _b !== void 0 ? _b : 25565,
+});
+bot.loadPlugin(index_1.default);
+//lazy implementation. Will automate throwing later.
+bot.on("chat", (username, message) => __awaiter(void 0, void 0, void 0, function* () {
+    var _c;
+    const split = message.split(" ");
+    switch (split[0]) {
+        case "pearl":
+            target = bot.nearestEntity((e) => { var _a; return ((_a = e.username) !== null && _a !== void 0 ? _a : e.name) === split[1]; });
+            if (!target) {
+                console.log("no entity");
+                return;
+            }
+            targetBlock = bot.blockAt(target.position.offset(0, -1, 0));
+            if (!targetBlock) {
+                console.log("no block under entity");
+                return;
+            }
+            const test = bot.ender.shotToBlock(targetBlock, 1);
+            // console.log("fuck", test)
+            if (!test || !(test === null || test === void 0 ? void 0 : test.hit))
+                return console.log("shit");
+            const item = bot.inventory.items().find(i => i.name === "ender_pearl");
+            if (!item)
+                return console.log("no ender pearl.");
+            yield bot.equip(item, "hand");
+            yield bot.look(test.yaw, test.pitch);
+            yield bot.waitForTicks(1);
+            console.log(test.yaw, test.pitch, (_c = test.shotInfo) === null || _c === void 0 ? void 0 : _c.landingDistance);
+            bot.swingArm(undefined);
+            bot.activateItem();
+            bot.deactivateItem();
+            break;
+        default:
+            console.log("hi");
+    }
+}));

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+import { EnderShotFactory } from "./enderShotFactory";
+import { Bot } from "mineflayer";
+import { Entity } from "prismarine-entity";
+import { EnderShotPlanner } from "./enderPlanner";
+declare module "mineflayer" {
+    interface Bot {
+        ender: EnderShotPlanner;
+    }
+    interface BotEvents {
+        attackedTarget: (target: Entity) => void;
+        stoppedAttacking: () => void;
+        startedAttacking: (target: Entity) => void;
+        targetBlockingUpdate: (target: Entity, blocking: boolean) => void;
+    }
+}
+export default function plugin(bot: Bot): void;
+export { EnderShotFactory };
+export { EnderShotPlanner };

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnderShotPlanner = exports.EnderShotFactory = void 0;
+const enderShotFactory_1 = require("./enderShotFactory");
+Object.defineProperty(exports, "EnderShotFactory", { enumerable: true, get: function () { return enderShotFactory_1.EnderShotFactory; } });
+const mineflayer_util_plugin_1 = __importDefault(require("@nxg-org/mineflayer-util-plugin"));
+const enderPlanner_1 = require("./enderPlanner");
+Object.defineProperty(exports, "EnderShotPlanner", { enumerable: true, get: function () { return enderPlanner_1.EnderShotPlanner; } });
+function plugin(bot) {
+    if (!bot.util)
+        bot.loadPlugin(mineflayer_util_plugin_1.default);
+    bot.ender = new enderPlanner_1.EnderShotPlanner(bot);
+}
+exports.default = plugin;

package/lib/types.d.ts

@@ -0,0 +1,36 @@
+import type { Block } from "prismarine-block";
+import type { Item } from "prismarine-item";
+import type { Vec3 } from "vec3";
+export declare type ShotEntity = {
+    position: Vec3;
+    velocity: Vec3;
+    yaw?: number;
+    pitch?: number;
+    heldItem?: Item | null;
+};
+export declare type AABBComponents = {
+    position: Vec3;
+    height: number;
+    width?: number;
+};
+export declare type ProjectileMotion = {
+    position: Vec3;
+    velocity: Vec3;
+    gravity?: number;
+};
+export declare type BasicShotInfo = {
+    landingDistance: number;
+    block: Block | null;
+    blockFace?: BlockFace;
+    closestPoint: Vec3 | null;
+    totalTicks: number;
+};
+export declare enum BlockFace {
+    UNKNOWN = -999,
+    BOTTOM = 0,
+    TOP = 1,
+    NORTH = 2,
+    SOUTH = 3,
+    WEST = 4,
+    EAST = 5
+}

package/lib/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockFace = void 0;
+var BlockFace;
+(function (BlockFace) {
+    BlockFace[BlockFace["UNKNOWN"] = -999] = "UNKNOWN";
+    BlockFace[BlockFace["BOTTOM"] = 0] = "BOTTOM";
+    BlockFace[BlockFace["TOP"] = 1] = "TOP";
+    BlockFace[BlockFace["NORTH"] = 2] = "NORTH";
+    BlockFace[BlockFace["SOUTH"] = 3] = "SOUTH";
+    BlockFace[BlockFace["WEST"] = 4] = "WEST";
+    BlockFace[BlockFace["EAST"] = 5] = "EAST";
+})(BlockFace = exports.BlockFace || (exports.BlockFace = {}));

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@nxg-org/mineflayer-ender",
+    "version": "1.0.1",
+    "description": "A plugin dedicated to bots being like endermen.",
+    "keywords": [
+        "mineflayer",
+        "mineflayer-util",
+        "mineflayer-plugin",
+        "mineflayer-ender"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nxg-org/mineflayer-ender.git"
+    },
+    "license": "GPL-3.0",
+    "author": "generel_schwerz",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "scripts": {
+        "build": "npx tsc",
+        "prepublish": "npm run build",
+        "test": "node --trace-warnings lib/example.js"
+    },
+    "dependencies": {
+        "@nxg-org/mineflayer-trajectories": "^1.0.4",
+        "@nxg-org/mineflayer-util-plugin": "^1.3.8",
+        "minecraft-data": "^2.97.0",
+        "mineflayer": "^3.11.2",
+        "mineflayer-pathfinder": "^1.8.0",
+        "prismarine-block": "^1.10.3",
+        "prismarine-item": "^1.11.1",
+        "vec3": "^0.1.7"
+    },
+    "devDependencies": {
+        "@types/node": "^16.11.11",
+        "typescript": "^4.5.2"
+    }
+}