@nxg-org/mineflayer-physics-util 1.5.5 → 1.5.7

package/dist/physics/engines/entityPhysics.js

@@ -294,10 +294,7 @@ class EntityPhysics {
         if (dz !== oldVelZ)
             vel.z = 0;
         if (dy !== oldVelY) {
-            if (entity.collisionBehavior.blockEffects &&
-                blockAtFeet &&
-                blockAtFeet.type === this.slimeBlockId &&
-                !entity.state.control.sneak) {
+            if (entity.collisionBehavior.blockEffects && blockAtFeet && blockAtFeet.type === this.slimeBlockId && !entity.state.control.sneak) {
                 vel.y = -vel.y;
             }
             else {
@@ -329,9 +326,7 @@ class EntityPhysics {
                         else if (block.type === this.bubblecolumnId) {
                             const down = !block.metadata;
                             const aboveBlock = world.getBlock(cursor.offset(0, 1, 0));
-                            const bubbleDrag = aboveBlock && aboveBlock.type === 0 /* air */
-                                ? physicsSettings_1.PhysicsSettings.bubbleColumnSurfaceDrag
-                                : physicsSettings_1.PhysicsSettings.bubbleColumnDrag;
+                            const bubbleDrag = aboveBlock && aboveBlock.type === 0 /* air */ ? physicsSettings_1.PhysicsSettings.bubbleColumnSurfaceDrag : physicsSettings_1.PhysicsSettings.bubbleColumnDrag;
                             if (down) {
                                 vel.y = Math.max(bubbleDrag.maxDown, vel.y - bubbleDrag.down);
                             }
@@ -592,6 +587,7 @@ class EntityPhysics {
             vel.x *= inertia;
             vel.z *= inertia;
         }
+        // this is player-only.
         else if (entity.state.elytraFlying) {
             const { pitch, sinPitch, cosPitch, lookDir } = (0, physicsUtils_1.getLookingVector)(entity.state);
             const horizontalSpeed = Math.sqrt(vel.x * vel.x + vel.z * vel.z);
@@ -600,20 +596,20 @@ class EntityPhysics {
             // cosPitch is in [0, 1], so cosPitch > 0.0 is just to protect against
             // divide by zero errors
             if (vel.y < 0.0 && cosPitch > 0.0) {
-                const movingDownSpeedModifier = vel.y * (-0.1) * cosPitchSquared;
-                vel.x += lookDir.x * movingDownSpeedModifier / cosPitch;
+                const movingDownSpeedModifier = vel.y * -0.1 * cosPitchSquared;
+                vel.x += (lookDir.x * movingDownSpeedModifier) / cosPitch;
                 vel.y += movingDownSpeedModifier;
-                vel.z += lookDir.z * movingDownSpeedModifier / cosPitch;
+                vel.z += (lookDir.z * movingDownSpeedModifier) / cosPitch;
             }
             if (pitch < 0.0 && cosPitch > 0.0) {
-                const lookDownSpeedModifier = horizontalSpeed * (-sinPitch) * 0.04;
-                vel.x += -lookDir.x * lookDownSpeedModifier / cosPitch;
+                const lookDownSpeedModifier = horizontalSpeed * -sinPitch * 0.04;
+                vel.x += (-lookDir.x * lookDownSpeedModifier) / cosPitch;
                 vel.y += lookDownSpeedModifier * 3.2;
-                vel.z += -lookDir.z * lookDownSpeedModifier / cosPitch;
+                vel.z += (-lookDir.z * lookDownSpeedModifier) / cosPitch;
             }
             if (cosPitch > 0.0) {
-                vel.x += (lookDir.x / cosPitch * horizontalSpeed - vel.x) * 0.1;
-                vel.z += (lookDir.z / cosPitch * horizontalSpeed - vel.z) * 0.1;
+                vel.x += ((lookDir.x / cosPitch) * horizontalSpeed - vel.x) * 0.1;
+                vel.z += ((lookDir.z / cosPitch) * horizontalSpeed - vel.z) * 0.1;
             }
             vel.x *= 0.99;
             vel.y *= 0.98;
@@ -686,12 +682,11 @@ class EntityPhysics {
                 if (entity.state.jumpTicks > 0)
                     entity.state.jumpTicks--;
                 if (entity.state.isInWater || entity.state.isInLava) {
-                    vel.y += Math.fround(0.4);
+                    vel.y += 0.04;
                 }
                 else if (entity.state.onGround && entity.state.jumpTicks === 0) {
                     const blockBelow = world.getBlock(entity.position.floored().offset(0, -0.5, 0));
-                    vel.y =
-                        Math.fround(0.42) * (blockBelow && blockBelow.type === this.honeyblockId ? physicsSettings_1.PhysicsSettings.honeyblockJumpSpeed : 1);
+                    vel.y = Math.fround(0.42) * (blockBelow && blockBelow.type === this.honeyblockId ? physicsSettings_1.PhysicsSettings.honeyblockJumpSpeed : 1);
                     if (entity.state.jumpBoost > 0) {
                         vel.y += 0.1 * entity.state.jumpBoost;
                     }
@@ -707,10 +702,8 @@ class EntityPhysics {
                 entity.state.jumpTicks = 0; // reset autojump cooldown
             }
             entity.state.jumpQueued = false;
-            strafe =
-                (entity.state.control.left - entity.state.control.right) * 0.98;
-            forward =
-                (entity.state.control.forward - entity.state.control.back) * 0.98;
+            strafe = (entity.state.control.left - entity.state.control.right) * 0.98;
+            forward = (entity.state.control.forward - entity.state.control.back) * 0.98;
             if (entity.state.control.sneak) {
                 strafe *= physicsSettings_1.PhysicsSettings.sneakSpeed;
                 forward *= physicsSettings_1.PhysicsSettings.sneakSpeed;
@@ -722,7 +715,8 @@ class EntityPhysics {
                 entity.state.control.sprint = false;
             }
         }
-        entity.state.elytraFlying = entity.state.elytraFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
+        entity.state.elytraFlying =
+            entity.state.elytraFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
         if (entity.state.fireworkRocketDuration > 0) {
             if (!entity.state.elytraFlying) {
                 entity.state.fireworkRocketDuration = 0;

package/dist/physics/engines/optimizedPhysics.d.ts

@@ -0,0 +1,79 @@
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
+import md from "minecraft-data";
+import { Block } from "prismarine-block";
+import { Effect } from "prismarine-entity";
+import { Vec3 } from "vec3";
+import { CheapEffects, CheapEnchantments, makeSupportFeature } from "../../util/physicsUtils";
+import { EPhysicsCtx } from "../settings/entityPhysicsCtx";
+import { EntityState } from "../states/entityState";
+import { IPhysics } from "./IPhysics";
+/**
+ * Looking at this code, it's too specified towards players.
+ *
+ * I will eventually split this code into PlayerState and bot.entityState, where bot.entityState contains fewer controls.
+ */
+export declare class EntityPhysics implements IPhysics {
+    data: md.IndexedData;
+    movementSpeedAttribute: any;
+    supportFeature: ReturnType<typeof makeSupportFeature>;
+    blockSlipperiness: {
+        [name: string]: number;
+    };
+    protected slimeBlockId: number;
+    protected soulsandId: number;
+    protected honeyblockId: number;
+    protected webId: number;
+    protected waterId: number;
+    protected lavaId: number;
+    protected ladderId: number;
+    protected vineId: number;
+    protected bubblecolumnId: number;
+    protected waterLike: Set<number>;
+    readonly statusEffectNames: {
+        [type in CheapEffects]: string;
+    };
+    readonly enchantmentNames: {
+        [type in CheapEnchantments]: string;
+    };
+    constructor(mcData: md.IndexedData);
+    getEntityBB(entity: EPhysicsCtx, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): AABB;
+    setPositionToBB(entity: EPhysicsCtx, bb: AABB, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    shouldMoveEntity(entity: EPhysicsCtx): boolean;
+    getUnderlyingBlockBBs(queryBB: AABB, world: any): AABB[];
+    getSurroundingBBs(queryBB: AABB, world: any): AABB[];
+    adjustPositionHeight(entity: EPhysicsCtx, pos: Vec3, world: any): void;
+    moveEntity(entity: EPhysicsCtx, dx: number, dy: number, dz: number, world: any): void;
+    applyHeading(entity: EPhysicsCtx, strafe: number, forward: number, multiplier: number): void;
+    getEffectLevel(wantedEffect: CheapEffects, effects: Effect[]): number;
+    getEnchantmentLevel(wantedEnchantment: CheapEnchantments, enchantments: any[]): any;
+    isOnLadder(pos: {
+        x: number;
+        y: number;
+        z: number;
+    }, world: any): any;
+    doesNotCollide(entity: EPhysicsCtx, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }, world: any): boolean;
+    isMaterialInBB(queryBB: AABB, type: number, world: any): boolean;
+    getWaterInBB(bb: AABB, world: any): any[];
+    getLiquidHeightPcent(block: Block): number;
+    getRenderedDepth(block: Block): number;
+    getFlow(block: Block, world: any): Vec3;
+    isInWaterApplyCurrent(bb: AABB, vel: {
+        x: number;
+        y: number;
+        z: number;
+    }, world: any): boolean;
+    moveEntityWithHeading(entity: EPhysicsCtx, strafe: number, forward: number, world: any): void;
+    simulate(entity: EPhysicsCtx, world: any): EntityState;
+}

package/dist/physics/engines/optimizedPhysics.js

@@ -0,0 +1,742 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityPhysics = void 0;
+const mineflayer_util_plugin_1 = require("@nxg-org/mineflayer-util-plugin");
+const vec3_1 = require("vec3");
+const physicsUtils_1 = require("../../util/physicsUtils");
+const attributes = __importStar(require("../info/attributes"));
+const math = __importStar(require("../info/math"));
+const physicsSettings_1 = require("../settings/physicsSettings");
+/**
+ * Looking at this code, it's too specified towards players.
+ *
+ * I will eventually split this code into PlayerState and bot.entityState, where bot.entityState contains fewer controls.
+ */
+class EntityPhysics {
+    constructor(mcData) {
+        this.data = mcData;
+        const blocksByName = mcData.blocksByName;
+        this.supportFeature = (0, physicsUtils_1.makeSupportFeature)(mcData);
+        this.movementSpeedAttribute = this.data.attributesByName.movementSpeed.resource;
+        this.blockSlipperiness = {};
+        this.slimeBlockId = blocksByName.slime_block ? blocksByName.slime_block.id : blocksByName.slime.id;
+        this.blockSlipperiness[this.slimeBlockId] = 0.8;
+        this.blockSlipperiness[blocksByName.ice.id] = 0.98;
+        this.blockSlipperiness[blocksByName.packed_ice.id] = 0.98;
+        // 1.9+
+        if (blocksByName.frosted_ice)
+            this.blockSlipperiness[blocksByName.frosted_ice.id] = 0.98;
+        // 1.13+
+        if (blocksByName.blue_ice)
+            this.blockSlipperiness[blocksByName.blue_ice.id] = 0.989;
+        this.soulsandId = blocksByName.soul_sand.id;
+        this.honeyblockId = blocksByName.honey_block ? blocksByName.honey_block.id : -1; // 1.15+
+        this.webId = blocksByName.cobweb ? blocksByName.cobweb.id : blocksByName.web.id;
+        this.waterId = blocksByName.water.id;
+        this.lavaId = blocksByName.lava.id;
+        this.ladderId = blocksByName.ladder.id;
+        this.vineId = blocksByName.vine.id;
+        this.waterLike = new Set();
+        if (blocksByName.seagrass)
+            this.waterLike.add(blocksByName.seagrass.id); // 1.13+
+        if (blocksByName.tall_seagrass)
+            this.waterLike.add(blocksByName.tall_seagrass.id); // 1.13+
+        if (blocksByName.kelp)
+            this.waterLike.add(blocksByName.kelp.id); // 1.13+
+        this.bubblecolumnId = blocksByName.bubble_column ? blocksByName.bubble_column.id : -1; // 1.13+
+        if (blocksByName.bubble_column)
+            this.waterLike.add(this.bubblecolumnId);
+        this.statusEffectNames = {}; // mmm, speed.
+        this.enchantmentNames = {}; //mmm, double speed.
+        let ind = 0;
+        const tmp = (0, physicsUtils_1.getStatusEffectNamesForVersion)(this.supportFeature);
+        for (const key in tmp) {
+            this.statusEffectNames[ind] = tmp[key];
+            ind++;
+        }
+        Object.freeze(this.statusEffectNames);
+        ind = 0;
+        const tmp1 = (0, physicsUtils_1.getEnchantmentNamesForVersion)(this.supportFeature);
+        for (const key in tmp1) {
+            this.enchantmentNames[ind] = tmp1[key];
+        }
+        Object.freeze(this.enchantmentNames);
+    }
+    getEntityBB(entity, pos) {
+        const w = entity.getHalfWidth();
+        return new mineflayer_util_plugin_1.AABB(-w, 0, -w, w, entity.height, w).translate(pos.x, pos.y, pos.z);
+    }
+    setPositionToBB(entity, bb, pos) {
+        const halfWidth = entity.getHalfWidth();
+        pos.x = bb.minX + halfWidth;
+        pos.y = bb.minY;
+        pos.z = bb.minZ + halfWidth;
+    }
+    shouldMoveEntity(entity) {
+        return !((entity.state.isCollidedHorizontally || entity.state.isCollidedVertically) &&
+            !entity.collisionBehavior.affectedAfterCollision);
+    }
+    getUnderlyingBlockBBs(queryBB, world /*prismarine-world*/) {
+        const surroundingBBs = [];
+        const cursor = new vec3_1.Vec3(0, Math.floor(queryBB.minY) - 0.251, 0);
+        for (cursor.z = Math.floor(queryBB.minZ); cursor.z <= Math.floor(queryBB.maxZ); cursor.z++) {
+            for (cursor.x = Math.floor(queryBB.minX); cursor.x <= Math.floor(queryBB.maxX); cursor.x++) {
+                const block = world.getBlock(cursor);
+                if (block) {
+                    const blockPos = block.position;
+                    for (const shape of block.shapes) {
+                        const blockBB = new mineflayer_util_plugin_1.AABB(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]);
+                        blockBB.translate(blockPos.x, blockPos.y, blockPos.z);
+                        surroundingBBs.push(blockBB);
+                    }
+                }
+            }
+        }
+        return surroundingBBs;
+    }
+    getSurroundingBBs(queryBB, world /*prismarine-world*/) {
+        const surroundingBBs = [];
+        const cursor = new vec3_1.Vec3(0, 0, 0);
+        for (cursor.y = Math.floor(queryBB.minY) - 1; cursor.y <= Math.floor(queryBB.maxY); cursor.y++) {
+            for (cursor.z = Math.floor(queryBB.minZ); cursor.z <= Math.floor(queryBB.maxZ); cursor.z++) {
+                for (cursor.x = Math.floor(queryBB.minX); cursor.x <= Math.floor(queryBB.maxX); cursor.x++) {
+                    const block = world.getBlock(cursor);
+                    if (block) {
+                        const blockPos = block.position;
+                        for (const shape of block.shapes) {
+                            const blockBB = new mineflayer_util_plugin_1.AABB(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]);
+                            blockBB.translate(blockPos.x, blockPos.y, blockPos.z);
+                            surroundingBBs.push(blockBB);
+                        }
+                    }
+                }
+            }
+        }
+        return surroundingBBs;
+    }
+    adjustPositionHeight(entity, pos, world /*prismarine-world*/) {
+        const playerBB = this.getEntityBB(entity, pos);
+        const queryBB = playerBB.clone().extend(0, -1, 0);
+        const surroundingBBs = this.getSurroundingBBs(queryBB, world);
+        let dy = -1;
+        for (const blockBB of surroundingBBs) {
+            dy = blockBB.computeOffsetY(playerBB, dy);
+        }
+        pos.y += dy;
+    }
+    moveEntity(entity, dx, dy, dz, world /*prismarine-world*/) {
+        var _a;
+        if (!this.shouldMoveEntity(entity)) {
+            entity.velocity.set(0, 0, 0);
+            return;
+        }
+        const vel = entity.velocity;
+        const pos = entity.position;
+        if (entity.state.isInWeb && !((_a = entity.entityType) === null || _a === void 0 ? void 0 : _a.name.includes("arrow"))) {
+            dx *= 0.25;
+            dy *= 0.05;
+            dz *= 0.25;
+            vel.x = 0;
+            vel.y = 0;
+            vel.z = 0;
+            entity.state.isInWeb = false;
+        }
+        const oldOldVelX = dx;
+        let oldVelX = dx;
+        const oldVelY = dy;
+        let oldVelZ = dz;
+        const oldOldVelZ = dz;
+        if (entity.useControls && entity.state.control.sneak && entity.state.onGround) {
+            const step = 0.05;
+            // In the 3 loops bellow, y offset should be -1, but that doesnt reproduce vanilla behavior.
+            for (; dx !== 0 && this.getSurroundingBBs(this.getEntityBB(entity, pos).translate(dx, 0, 0), world).length === 0; oldVelX = dx) {
+                if (dx < step && dx >= -step)
+                    dx = 0;
+                else if (dx > 0)
+                    dx -= step;
+                else
+                    dx += step;
+            }
+            for (; dz !== 0 && this.getSurroundingBBs(this.getEntityBB(entity, pos).translate(0, 0, dz), world).length === 0; oldVelZ = dz) {
+                if (dz < step && dz >= -step)
+                    dz = 0;
+                else if (dz > 0)
+                    dz -= step;
+                else
+                    dz += step;
+            }
+            while (dx !== 0 && dz !== 0 && this.getSurroundingBBs(this.getEntityBB(entity, pos).translate(dx, 0, dz), world).length === 0) {
+                if (dx < step && dx >= -step)
+                    dx = 0;
+                else if (dx > 0)
+                    dx -= step;
+                else
+                    dx += step;
+                if (dz < step && dz >= -step)
+                    dz = 0;
+                else if (dz > 0)
+                    dz -= step;
+                else
+                    dz += step;
+                oldVelX = dx;
+                oldVelZ = dz;
+            }
+        }
+        let playerBB = this.getEntityBB(entity, pos);
+        const queryBB = playerBB.clone().extend(dx, dy, dz);
+        const surroundingBBs = this.getSurroundingBBs(queryBB, world);
+        const oldBB = playerBB.clone();
+        for (const blockBB of surroundingBBs) {
+            dy = blockBB.computeOffsetY(playerBB, dy);
+        }
+        playerBB.translate(0, dy, 0);
+        for (const blockBB of surroundingBBs) {
+            dx = blockBB.computeOffsetX(playerBB, dx);
+        }
+        playerBB.translate(dx, 0, 0);
+        for (const blockBB of surroundingBBs) {
+            dz = blockBB.computeOffsetZ(playerBB, dz);
+        }
+        playerBB.translate(0, 0, dz);
+        // Step on block if height < stepHeight
+        if (entity.stepHeight > 0 && (entity.state.onGround || (dy !== oldVelY && oldVelY < 0)) && (dx !== oldVelX || dz !== oldVelZ)) {
+            const oldVelXCol = dx;
+            const oldVelYCol = dy;
+            const oldVelZCol = dz;
+            const oldBBCol = playerBB.clone();
+            dy = entity.stepHeight;
+            const queryBB = oldBB.clone().extend(oldVelX, dy, oldVelZ);
+            const surroundingBBs = this.getSurroundingBBs(queryBB, world);
+            const BB1 = oldBB.clone();
+            const BB2 = oldBB.clone();
+            const BB_XZ = BB1.clone().extend(dx, 0, dz);
+            let dy1 = dy;
+            let dy2 = dy;
+            for (const blockBB of surroundingBBs) {
+                dy1 = blockBB.computeOffsetY(BB_XZ, dy1);
+                dy2 = blockBB.computeOffsetY(BB2, dy2);
+            }
+            BB1.translate(0, dy1, 0);
+            BB2.translate(0, dy2, 0);
+            let dx1 = oldVelX;
+            let dx2 = oldVelX;
+            for (const blockBB of surroundingBBs) {
+                dx1 = blockBB.computeOffsetX(BB1, dx1);
+                dx2 = blockBB.computeOffsetX(BB2, dx2);
+            }
+            BB1.translate(dx1, 0, 0);
+            BB2.translate(dx2, 0, 0);
+            let dz1 = oldVelZ;
+            let dz2 = oldVelZ;
+            for (const blockBB of surroundingBBs) {
+                dz1 = blockBB.computeOffsetZ(BB1, dz1);
+                dz2 = blockBB.computeOffsetZ(BB2, dz2);
+            }
+            BB1.translate(0, 0, dz1);
+            BB2.translate(0, 0, dz2);
+            const norm1 = dx1 * dx1 + dz1 * dz1;
+            const norm2 = dx2 * dx2 + dz2 * dz2;
+            if (norm1 > norm2) {
+                dx = dx1;
+                dy = -dy1;
+                dz = dz1;
+                playerBB = BB1;
+            }
+            else {
+                dx = dx2;
+                dy = -dy2;
+                dz = dz2;
+                playerBB = BB2;
+            }
+            for (const blockBB of surroundingBBs) {
+                dy = blockBB.computeOffsetY(playerBB, dy);
+            }
+            playerBB.translate(0, dy, 0);
+            if (oldVelXCol * oldVelXCol + oldVelZCol * oldVelZCol >= dx * dx + dz * dz) {
+                dx = oldVelXCol;
+                dy = oldVelYCol;
+                dz = oldVelZCol;
+                playerBB = oldBBCol;
+            }
+        }
+        // Update flags
+        this.setPositionToBB(entity, playerBB, pos);
+        entity.state.sneakCollision = dx !== oldOldVelX || dz !== oldOldVelZ;
+        entity.state.isCollidedHorizontally = dx !== oldVelX || dz !== oldVelZ;
+        entity.state.isCollidedVertically = dy !== oldVelY;
+        entity.state.onGround = entity.state.isCollidedVertically && oldVelY < 0;
+        const blockAtFeet = world.getBlock(pos.offset(0, -0.2, 0));
+        if (dx !== oldVelX)
+            vel.x = 0;
+        if (dz !== oldVelZ)
+            vel.z = 0;
+        if (dy !== oldVelY) {
+            if (entity.collisionBehavior.blockEffects &&
+                blockAtFeet &&
+                blockAtFeet.type === this.slimeBlockId &&
+                !entity.state.control.sneak) {
+                vel.y = -vel.y;
+            }
+            else {
+                vel.y = 0;
+            }
+        }
+        // Finally, apply block collisions (web, soulsand...)
+        playerBB.contract(0.001, 0.001, 0.001);
+        const cursor = new vec3_1.Vec3(0, 0, 0);
+        for (cursor.y = Math.floor(playerBB.minY); cursor.y <= Math.floor(playerBB.maxY); cursor.y++) {
+            for (cursor.z = Math.floor(playerBB.minZ); cursor.z <= Math.floor(playerBB.maxZ); cursor.z++) {
+                for (cursor.x = Math.floor(playerBB.minX); cursor.x <= Math.floor(playerBB.maxX); cursor.x++) {
+                    const block = world.getBlock(cursor);
+                    if (block) {
+                        if (entity.collisionBehavior.blockEffects && this.supportFeature("velocityBlocksOnCollision")) {
+                            if (block.type === this.soulsandId) {
+                                vel.x *= physicsSettings_1.PhysicsSettings.soulsandSpeed;
+                                vel.z *= physicsSettings_1.PhysicsSettings.soulsandSpeed;
+                            }
+                            else if (block.type === this.honeyblockId) {
+                                vel.x *= physicsSettings_1.PhysicsSettings.honeyblockSpeed;
+                                vel.z *= physicsSettings_1.PhysicsSettings.honeyblockSpeed;
+                            }
+                        }
+                        if (block.type === this.webId) {
+                            entity.state.isInWeb = true;
+                        }
+                        // no blockEffects check here, apparently all entities are affected by this.
+                        else if (block.type === this.bubblecolumnId) {
+                            const down = !block.metadata;
+                            const aboveBlock = world.getBlock(cursor.offset(0, 1, 0));
+                            const bubbleDrag = aboveBlock && aboveBlock.type === 0 /* air */
+                                ? physicsSettings_1.PhysicsSettings.bubbleColumnSurfaceDrag
+                                : physicsSettings_1.PhysicsSettings.bubbleColumnDrag;
+                            if (down) {
+                                vel.y = Math.max(bubbleDrag.maxDown, vel.y - bubbleDrag.down);
+                            }
+                            else {
+                                vel.y = Math.min(bubbleDrag.maxUp, vel.y + bubbleDrag.up);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (entity.collisionBehavior.blockEffects && this.supportFeature("velocityBlocksOnTop")) {
+            const blockBelow = world.getBlock(entity.position.floored().offset(0, -0.5, 0));
+            if (blockBelow) {
+                if (blockBelow.type === this.soulsandId) {
+                    vel.x *= physicsSettings_1.PhysicsSettings.soulsandSpeed;
+                    vel.z *= physicsSettings_1.PhysicsSettings.soulsandSpeed;
+                }
+                else if (blockBelow.type === this.honeyblockId) {
+                    vel.x *= physicsSettings_1.PhysicsSettings.honeyblockSpeed;
+                    vel.z *= physicsSettings_1.PhysicsSettings.honeyblockSpeed;
+                }
+            }
+        }
+    }
+    applyHeading(entity, strafe, forward, multiplier) {
+        if (!this.shouldMoveEntity(entity)) {
+            entity.velocity.set(0, 0, 0);
+            return;
+        }
+        let speed = Math.sqrt(strafe * strafe + forward * forward);
+        if (speed < 0.01)
+            return;
+        speed = multiplier / Math.max(speed, 1);
+        strafe *= speed;
+        forward *= speed;
+        const yaw = Math.PI - entity.state.yaw;
+        const sin = Math.sin(yaw);
+        const cos = Math.cos(yaw);
+        const vel = entity.velocity;
+        vel.x += strafe * cos - forward * sin;
+        vel.z += forward * cos + strafe * sin;
+    }
+    getEffectLevel(wantedEffect, effects) {
+        const effectDescriptor = this.data.effectsByName[this.statusEffectNames[wantedEffect]];
+        if (!effectDescriptor) {
+            return 0;
+        }
+        const effectInfo = effects[effectDescriptor.id];
+        if (!effectInfo) {
+            return 0;
+        }
+        return effectInfo.amplifier + 1;
+    }
+    getEnchantmentLevel(wantedEnchantment, enchantments) {
+        const enchantmentName = this.enchantmentNames[wantedEnchantment];
+        const enchantmentDescriptor = this.data.enchantmentsByName[enchantmentName];
+        if (!enchantmentDescriptor) {
+            return 0;
+        }
+        for (const enchInfo of enchantments) {
+            if (typeof enchInfo.id === "string") {
+                if (enchInfo.id.includes(enchantmentName)) {
+                    return enchInfo.lvl;
+                }
+            }
+            else if (enchInfo.id === enchantmentDescriptor.id) {
+                return enchInfo.lvl;
+            }
+        }
+        return 0;
+    }
+    isOnLadder(pos, world /*prismarine-world*/) {
+        const block = world.getBlock(pos);
+        return block && (block.type === this.ladderId || block.type === this.vineId);
+    }
+    doesNotCollide(entity, pos, world /*prismarine-world*/) {
+        const pBB = this.getEntityBB(entity, pos);
+        return !this.getSurroundingBBs(pBB, world).some((x) => pBB.intersects(x)) && this.getWaterInBB(pBB, world).length === 0;
+    }
+    isMaterialInBB(queryBB, type, world /*prismarine-world*/) {
+        const cursor = new vec3_1.Vec3(0, 0, 0);
+        for (cursor.y = Math.floor(queryBB.minY); cursor.y <= Math.floor(queryBB.maxY); cursor.y++) {
+            for (cursor.z = Math.floor(queryBB.minZ); cursor.z <= Math.floor(queryBB.maxZ); cursor.z++) {
+                for (cursor.x = Math.floor(queryBB.minX); cursor.x <= Math.floor(queryBB.maxX); cursor.x++) {
+                    const block = world.getBlock(cursor);
+                    if (block && block.type === type)
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    getWaterInBB(bb, world /*prismarine-world*/) {
+        const waterBlocks = [];
+        const cursor = new vec3_1.Vec3(0, 0, 0);
+        for (cursor.y = Math.floor(bb.minY); cursor.y <= Math.floor(bb.maxY); cursor.y++) {
+            for (cursor.z = Math.floor(bb.minZ); cursor.z <= Math.floor(bb.maxZ); cursor.z++) {
+                for (cursor.x = Math.floor(bb.minX); cursor.x <= Math.floor(bb.maxX); cursor.x++) {
+                    const block = world.getBlock(cursor);
+                    if (block && (block.type === this.waterId || this.waterLike.has(block.type) || block.getProperties().waterlogged)) {
+                        const waterLevel = cursor.y + 1 - this.getLiquidHeightPcent(block);
+                        if (Math.ceil(bb.maxY) >= waterLevel)
+                            waterBlocks.push(block);
+                    }
+                }
+            }
+        }
+        return waterBlocks;
+    }
+    getLiquidHeightPcent(block) {
+        return (this.getRenderedDepth(block) + 1) / 9;
+    }
+    getRenderedDepth(block) {
+        if (!block)
+            return -1;
+        if (this.waterLike.has(block.type))
+            return 0;
+        if (block.getProperties().waterlogged)
+            return 0;
+        if (block.type !== this.waterId)
+            return -1;
+        const meta = block.metadata;
+        return meta >= 8 ? 0 : meta;
+    }
+    getFlow(block, world /*prismarine-world*/) {
+        const curlevel = this.getRenderedDepth(block);
+        const flow = new vec3_1.Vec3(0, 0, 0);
+        for (const [dx, dz] of [
+            [0, 1],
+            [-1, 0],
+            [0, -1],
+            [1, 0],
+        ]) {
+            const adjBlock = world.getBlock(block.position.offset(dx, 0, dz));
+            const adjLevel = this.getRenderedDepth(adjBlock);
+            if (adjLevel < 0) {
+                if (adjBlock && adjBlock.boundingBox !== "empty") {
+                    const adjLevel = this.getRenderedDepth(world.getBlock(block.position.offset(dx, -1, dz)));
+                    if (adjLevel >= 0) {
+                        const f = adjLevel - (curlevel - 8);
+                        flow.x += dx * f;
+                        flow.z += dz * f;
+                    }
+                }
+            }
+            else {
+                const f = adjLevel - curlevel;
+                flow.x += dx * f;
+                flow.z += dz * f;
+            }
+        }
+        if (block.metadata >= 8) {
+            for (const [dx, dz] of [
+                [0, 1],
+                [-1, 0],
+                [0, -1],
+                [1, 0],
+            ]) {
+                const adjBlock = world.getBlock(block.position.offset(dx, 0, dz));
+                const adjUpBlock = world.getBlock(block.position.offset(dx, 1, dz));
+                if ((adjBlock && adjBlock.boundingBox !== "empty") || (adjUpBlock && adjUpBlock.boundingBox !== "empty")) {
+                    flow.normalize().translate(0, -6, 0);
+                }
+            }
+        }
+        return flow.normalize();
+    }
+    isInWaterApplyCurrent(bb, vel, world /*prismarine-world*/) {
+        const acceleration = new vec3_1.Vec3(0, 0, 0);
+        const waterBlocks = this.getWaterInBB(bb, world);
+        const isInWater = waterBlocks.length > 0;
+        for (const block of waterBlocks) {
+            const flow = this.getFlow(block, world);
+            acceleration.add(flow);
+        }
+        const len = acceleration.norm();
+        if (len > 0) {
+            vel.x += (acceleration.x / len) * 0.014;
+            vel.y += (acceleration.y / len) * 0.014;
+            vel.z += (acceleration.z / len) * 0.014;
+        }
+        return isInWater;
+    }
+    moveEntityWithHeading(entity, strafe, forward, world /*prismarine-world*/) {
+        if (!this.shouldMoveEntity(entity)) {
+            entity.velocity.set(0, 0, 0);
+            return;
+        }
+        const vel = entity.velocity;
+        const pos = entity.position;
+        const gravityMultiplier = vel.y <= 0 && entity.state.slowFalling > 0 ? physicsSettings_1.PhysicsSettings.slowFalling : 1;
+        // Unsure how to handle this w/ other entities.
+        if (!entity.state.isInWater && !entity.state.isInLava) {
+            let acceleration = entity.airborneAccel;
+            let inertia = entity.airborneInertia;
+            const blockUnder = world.getBlock(pos.offset(0, -1, 0));
+            if (entity.state.onGround && blockUnder) {
+                let playerSpeedAttribute;
+                if (entity.state.attributes && entity.state.attributes[this.movementSpeedAttribute]) {
+                    // Use server-side player attributes
+                    playerSpeedAttribute = entity.state.attributes[this.movementSpeedAttribute];
+                }
+                else {
+                    // Create an attribute if the player does not have it
+                    //TODO: Generalize to all entities.
+                    playerSpeedAttribute = attributes.createAttributeValue(physicsSettings_1.PhysicsSettings.playerSpeed);
+                }
+                // Client-side sprinting (don't rely on server-side sprinting)
+                // setSprinting in LivingEntity.java
+                //TODO: Generalize to all entities.
+                playerSpeedAttribute = attributes.deleteAttributeModifier(playerSpeedAttribute, physicsSettings_1.PhysicsSettings.sprintingUUID); // always delete sprinting (if it exists)
+                if (entity.state.control.sprint) {
+                    if (!attributes.checkAttributeModifier(playerSpeedAttribute, physicsSettings_1.PhysicsSettings.sprintingUUID)) {
+                        playerSpeedAttribute = attributes.addAttributeModifier(playerSpeedAttribute, {
+                            uuid: physicsSettings_1.PhysicsSettings.sprintingUUID,
+                            amount: physicsSettings_1.PhysicsSettings.sprintSpeed,
+                            operation: 2,
+                        });
+                    }
+                }
+                // Calculate what the speed is (0.1 if no modification)
+                const attributeSpeed = attributes.getAttributeValue(playerSpeedAttribute);
+                inertia = (this.blockSlipperiness[blockUnder.type] || physicsSettings_1.PhysicsSettings.defaultSlipperiness) * 0.91;
+                acceleration = attributeSpeed * (0.1627714 / (inertia * inertia * inertia));
+                if (acceleration < 0)
+                    acceleration = 0; // acceleration should not be negative
+            }
+            this.applyHeading(entity, strafe, forward, acceleration);
+            if (entity.collisionBehavior.blockEffects && this.isOnLadder(pos, world)) {
+                vel.x = math.clamp(-physicsSettings_1.PhysicsSettings.ladderMaxSpeed, vel.x, physicsSettings_1.PhysicsSettings.ladderMaxSpeed);
+                vel.z = math.clamp(-physicsSettings_1.PhysicsSettings.ladderMaxSpeed, vel.z, physicsSettings_1.PhysicsSettings.ladderMaxSpeed);
+                vel.y = Math.max(vel.y, entity.state.control.sneak ? 0 : -physicsSettings_1.PhysicsSettings.ladderMaxSpeed);
+            }
+            this.moveEntity(entity, vel.x, vel.y, vel.z, world);
+            if (entity.collisionBehavior.blockEffects &&
+                this.isOnLadder(pos, world) &&
+                (entity.state.isCollidedHorizontally || (this.supportFeature("climbUsingJump") && entity.state.control.jump))) {
+                vel.y = physicsSettings_1.PhysicsSettings.ladderClimbSpeed; // climb ladder
+            }
+            // Not adding an additional function call. No point.
+            if (entity.gravityThenDrag) {
+                // Apply gravity, then air drag.
+                if (entity.state.levitation > 0)
+                    vel.y += (0.05 * entity.state.levitation - vel.y) * 0.2;
+                else
+                    vel.y -= entity.gravity * gravityMultiplier;
+                vel.y *= entity.airdrag;
+            }
+            else {
+                // Apply airdrag, then gravity.
+                vel.y *= entity.airdrag;
+                if (entity.state.levitation > 0)
+                    vel.y += (0.05 * entity.state.levitation - vel.y) * 0.2;
+                else
+                    vel.y -= entity.gravity * gravityMultiplier;
+            }
+            vel.x *= inertia;
+            vel.z *= inertia;
+        }
+        else if (entity.state.elytraFlying) {
+            const { pitch, sinPitch, cosPitch, lookDir } = (0, physicsUtils_1.getLookingVector)(entity.state);
+            const horizontalSpeed = Math.sqrt(vel.x * vel.x + vel.z * vel.z);
+            const cosPitchSquared = cosPitch * cosPitch;
+            vel.y += entity.gravity * gravityMultiplier * (-1.0 + cosPitchSquared * 0.75);
+            // cosPitch is in [0, 1], so cosPitch > 0.0 is just to protect against
+            // divide by zero errors
+            if (vel.y < 0.0 && cosPitch > 0.0) {
+                const movingDownSpeedModifier = vel.y * (-0.1) * cosPitchSquared;
+                vel.x += lookDir.x * movingDownSpeedModifier / cosPitch;
+                vel.y += movingDownSpeedModifier;
+                vel.z += lookDir.z * movingDownSpeedModifier / cosPitch;
+            }
+            if (pitch < 0.0 && cosPitch > 0.0) {
+                const lookDownSpeedModifier = horizontalSpeed * (-sinPitch) * 0.04;
+                vel.x += -lookDir.x * lookDownSpeedModifier / cosPitch;
+                vel.y += lookDownSpeedModifier * 3.2;
+                vel.z += -lookDir.z * lookDownSpeedModifier / cosPitch;
+            }
+            if (cosPitch > 0.0) {
+                vel.x += (lookDir.x / cosPitch * horizontalSpeed - vel.x) * 0.1;
+                vel.z += (lookDir.z / cosPitch * horizontalSpeed - vel.z) * 0.1;
+            }
+            vel.x *= 0.99;
+            vel.y *= 0.98;
+            vel.z *= 0.99;
+            this.moveEntity(entity, world, vel.x, vel.y, vel.z);
+            if (entity.state.onGround) {
+                entity.state.elytraFlying = false;
+            }
+        }
+        else {
+            // Water / Lava movement
+            const lastY = pos.y;
+            let acceleration = entity.liquidAccel;
+            const inertia = entity.state.isInWater ? entity.waterInertia : entity.lavaInertia;
+            let horizontalInertia = inertia;
+            if (entity.state.isInWater) {
+                let strider = Math.min(entity.state.depthStrider, 3);
+                if (!entity.state.onGround) {
+                    strider *= 0.5;
+                }
+                if (strider > 0) {
+                    horizontalInertia += ((0.546 - horizontalInertia) * strider) / 3;
+                    acceleration += ((0.7 - acceleration) * strider) / 3;
+                }
+                if (entity.state.dolphinsGrace > 0)
+                    horizontalInertia = 0.96;
+            }
+            this.applyHeading(entity, strafe, forward, acceleration);
+            this.moveEntity(entity, vel.x, vel.y, vel.z, world);
+            if (entity.gravityThenDrag) {
+                vel.y -= (entity.state.isInWater ? entity.waterGravity : entity.lavaGravity) * gravityMultiplier;
+                vel.y *= inertia;
+            }
+            else {
+                vel.y *= inertia;
+                vel.y -= (entity.state.isInWater ? entity.waterGravity : entity.lavaGravity) * gravityMultiplier;
+            }
+            vel.x *= horizontalInertia;
+            vel.z *= horizontalInertia;
+            if (entity.state.isCollidedHorizontally &&
+                this.doesNotCollide(entity, pos.offset(vel.x, vel.y + 0.6 - pos.y + lastY, vel.z), world)) {
+                vel.y = physicsSettings_1.PhysicsSettings.outOfLiquidImpulse; // jump out of liquid
+            }
+        }
+    }
+    simulate(entity, world /*prismarine-world*/) {
+        if (!this.shouldMoveEntity(entity)) {
+            entity.velocity.set(0, 0, 0);
+            return entity.state;
+        }
+        const vel = entity.velocity;
+        const pos = entity.position;
+        const waterBB = this.getEntityBB(entity, pos).contract(0.001, 0.401, 0.001);
+        const lavaBB = this.getEntityBB(entity, pos).contract(0.1, 0.4, 0.1);
+        // assume that if we shouldn't move entity, isInWater and isInLava are already properly set.
+        entity.state.isInWater = this.isInWaterApplyCurrent(waterBB, vel, world);
+        entity.state.isInLava = this.isMaterialInBB(lavaBB, this.lavaId, world);
+        // Reset velocity component if it falls under the threshold
+        if (Math.abs(vel.x) < physicsSettings_1.PhysicsSettings.negligeableVelocity)
+            vel.x = 0;
+        if (Math.abs(vel.y) < physicsSettings_1.PhysicsSettings.negligeableVelocity)
+            vel.y = 0;
+        if (Math.abs(vel.z) < physicsSettings_1.PhysicsSettings.negligeableVelocity)
+            vel.z = 0;
+        let strafe = 0;
+        let forward = 0;
+        // Handle inputs
+        if (entity.useControls) {
+            if (entity.state.control.jump || entity.state.jumpQueued) {
+                if (entity.state.jumpTicks > 0)
+                    entity.state.jumpTicks--;
+                if (entity.state.isInWater || entity.state.isInLava) {
+                    vel.y += 0.04; // according to prismarine-physics
+                }
+                else if (entity.state.onGround && entity.state.jumpTicks === 0) {
+                    const blockBelow = world.getBlock(entity.position.floored().offset(0, -0.5, 0));
+                    vel.y =
+                        Math.fround(0.42) * (blockBelow && blockBelow.type === this.honeyblockId ? physicsSettings_1.PhysicsSettings.honeyblockJumpSpeed : 1);
+                    if (entity.state.jumpBoost > 0) {
+                        vel.y += 0.1 * entity.state.jumpBoost;
+                    }
+                    if (entity.state.control.sprint) {
+                        const yaw = Math.PI - entity.state.yaw;
+                        vel.x -= Math.sin(yaw) * 0.2;
+                        vel.z += Math.cos(yaw) * 0.2;
+                    }
+                    entity.state.jumpTicks = physicsSettings_1.PhysicsSettings.autojumpCooldown;
+                }
+            }
+            else {
+                entity.state.jumpTicks = 0; // reset autojump cooldown
+            }
+            entity.state.jumpQueued = false;
+            strafe =
+                (entity.state.control.left - entity.state.control.right) * 0.98;
+            forward =
+                (entity.state.control.forward - entity.state.control.back) * 0.98;
+            if (entity.state.control.sneak) {
+                strafe *= physicsSettings_1.PhysicsSettings.sneakSpeed;
+                forward *= physicsSettings_1.PhysicsSettings.sneakSpeed;
+                entity.state.control.sprint = false;
+            }
+            if (entity.state.isUsingItem) {
+                strafe *= physicsSettings_1.PhysicsSettings.usingItemSpeed;
+                forward *= physicsSettings_1.PhysicsSettings.usingItemSpeed;
+                entity.state.control.sprint = false;
+            }
+        }
+        entity.state.elytraFlying = entity.state.elytraFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
+        if (entity.state.fireworkRocketDuration > 0) {
+            if (!entity.state.elytraFlying) {
+                entity.state.fireworkRocketDuration = 0;
+            }
+            else {
+                const { lookDir } = (0, physicsUtils_1.getLookingVector)(entity.state);
+                vel.x += lookDir.x * 0.1 + (lookDir.x * 1.5 - vel.x) * 0.5;
+                vel.y += lookDir.y * 0.1 + (lookDir.y * 1.5 - vel.y) * 0.5;
+                vel.z += lookDir.z * 0.1 + (lookDir.z * 1.5 - vel.z) * 0.5;
+                --entity.state.fireworkRocketDuration;
+            }
+        }
+        this.moveEntityWithHeading(entity, strafe, forward, world);
+        return entity.state;
+    }
+}
+exports.EntityPhysics = EntityPhysics;

package/dist/physics/states/entityState.d.ts

@@ -96,6 +96,8 @@ export declare class EntityState implements EntityStateBuilder {
      * @returns AABB
      */
     getAABB(): AABB;
+    lookAt(vec3: Vec3): void;
+    look(yaw: number, pitch: number): void;
     getUnderlyingBlockBBs(world: any): AABB[];
     getSurroundingBBs(world: any): AABB[];
 }

package/dist/physics/states/entityState.js

@@ -258,6 +258,17 @@ class EntityState {
         const w = this.halfWidth;
         return new mineflayer_util_plugin_1.AABB(this.pos.x - w, this.pos.y, this.pos.z - w, this.pos.x + w, this.pos.y + this.height, this.pos.z + w);
     }
+    lookAt(vec3) {
+        const dx = vec3.x - this.pos.x;
+        const dy = vec3.y - this.pos.y;
+        const dz = vec3.z - this.pos.z;
+        this.yaw = Math.atan2(dz, dx) * 180 / Math.PI - 90;
+        this.pitch = -Math.atan2(dy, Math.sqrt(dx * dx + dz * dz)) * 180 / Math.PI;
+    }
+    look(yaw, pitch) {
+        this.yaw = yaw;
+        this.pitch = pitch;
+    }
     getUnderlyingBlockBBs(world /*prismarine-world*/) {
         const queryBB = this.getAABB();
         return this.ctx.getUnderlyingBlockBBs(queryBB, world);

package/dist/physics/states/playerState.d.ts

@@ -26,6 +26,7 @@ export declare class EntityDimensions {
 export declare class PlayerState implements EntityStateBuilder {
     readonly bot: Bot;
     height: number;
+    eyeHeight: number;
     halfWidth: number;
     pos: Vec3;
     vel: Vec3;

package/dist/physics/states/playerState.js

@@ -72,7 +72,8 @@ exports.EntityDimensions = EntityDimensions;
 class PlayerState {
     constructor(ctx, bot, control) {
         var _a, _b, _c, _d, _e;
-        this.height = 1.62;
+        this.height = 1.8;
+        this.eyeHeight = 1.62;
         this.halfWidth = 0.3;
         this.supportFeature = (0, physicsUtils_1.makeSupportFeature)(ctx.data);
         this.ctx = ctx;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nxg-org/mineflayer-physics-util",
-    "version": "1.5.5",
+    "version": "1.5.7",
     "description": "Provides functionality for more accurate entity and projectile tracking.",
     "keywords": [
         "mineflayer",
@@ -25,7 +25,7 @@
     },
     "devDependencies": {
         "expect": "^29.5.0",
-        "mineflayer": "^4.17.0",
+        "mineflayer": "^4.18.0",
         "mineflayer-pathfinder": "^2.4.4",
         "prismarine-entity": "^2.4.0",
         "typescript": "^4.5.5"

package/tests/actualBot.ts

@@ -11,12 +11,22 @@ const bot: Bot = createBot({
     username: "testingbot"
 })
 
-bot.once('spawn', () => {
+bot.once('spawn', async () => {
     bot.loadPlugin(loader)
     bot.loadPlugin(pathfinder)
+    await bot.waitForTicks(20)
+    bot.chat('rocky1928')
 })
 
 
+const rl = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+
+})
+
+rl.on('line', (line: any) => bot.chat(line))
+
 bot.on("chat", (user, message) => {
     const [cmd, ...args] = message.split(' ')
     const author = bot.nearestEntity(e=>e.username===user);
@@ -28,14 +38,24 @@ bot.on("chat", (user, message) => {
             bot.physics = new Physics(bot.registry, bot.world);
             break;
         case "new":
-            // rough patching in custom physics for the time being.
-            const fuck0 =  new EntityPhysics(bot.registry)
-            bot.physics = fuck0 as any;
-            (bot.physics as any).simulatePlayer = (state: EntityState, world: any /* prismarine-world*/) =>  {
-                const entity = EPhysicsCtx.FROM_ENTITY_STATE(fuck0, state)
-                return fuck0.simulate(entity, world);
-            }
+            const val = new EntityPhysics(bot.registry)
+            const oldSim = (bot.physics as any).simulatePlayer;
+
+            (EntityState.prototype as any).apply = function (bot: Bot) {
+                this.applyToBot(bot);
+              };
+            (bot.physics as any).simulatePlayer = (...args: any[]) => {
+            //   bot.jumpTicks = 0
+              const ctx = EPhysicsCtx.FROM_BOT(val, bot)
+              ctx.state.jumpTicks = 0; // allow immediate jumping
+              // ctx.state.control.set('sneak', true)
+              return val.simulate(ctx, bot.world);
+              return oldSim(...args);
+            };
             break;
+        case "jump":
+            bot.setControlState('jump', true)
+            break
         case "come":
             if (!author) return bot.chat(`Cannot see ${user}!`);
             const goal0 = new goals.GoalNear(author.position.x, author.position.y, author.position.z, 3);
@@ -48,6 +68,7 @@ bot.on("chat", (user, message) => {
             break;
         case "stop":
             bot.pathfinder.stop();
+            bot.clearControlStates();
             bot.chat('Stopped!')
             break;