@nxg-org/mineflayer-physics-util 1.7.8 → 1.7.10

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

@@ -112,7 +112,10 @@ export declare class BotcraftPhysics implements IPhysics {
     movePlayer(ctx: EPhysicsCtx, world: World): void;
     applyMovement(ctx: EPhysicsCtx, world: World): void;
     checkInsideBlocks(player: PlayerState, world: World): void;
-    collideBoundingBox(world: World, bb: AABB, movement: Vec3): Vec3;
+    collideBoundingBox(world: World, bb: AABB, movement: Vec3, colliders?: AABB[]): Vec3;
+    private collideWithShapes;
+    shapeCollide(axis: number, bb: AABB, colliders: AABB[], movement: number): number;
+    private voxelShapeCollide;
     collideOneAxis(movedAABB: AABB, movement: Vec3, axis: number, colliders: AABB[]): void;
     applyInputs(inputStrength: number, player: PlayerState): void;
     isInClimbable(player: PlayerState, world: World): boolean;

package/dist/physics/engines/botcraft.js

@@ -212,12 +212,9 @@ class BotcraftPhysics {
             }
         }
         const playerFlag = ctx.entityType.type === "player";
-        // if world is currently loaded at player position
-        if (playerFlag) {
-            // TODO: check if spectator mode
-        }
         this.fluidPhysics(ctx, world, true);
         this.fluidPhysics(ctx, world, false);
+        // updateSwimming moved into AiStep.
         // separation into a new function
         // originally: https://github.com/adepierre/Botcraft/blob/6c572071b0237c27a85211a246ce10565ef4d80f/botcraft/src/Game/Physics/PhysicsManager.cpp#L325
         if (playerFlag) {
@@ -697,12 +694,14 @@ class BotcraftPhysics {
                         blockJumpFactor = 0.4;
                     }
                     if (this.verLessThan("1.20.5")) {
-                        player.vel.y = 0.42 * blockJumpFactor + jumpBoost;
+                        player.vel.y = Math.fround(0.42) * blockJumpFactor + jumpBoost;
                         if (player.sprinting) {
-                            const yawRad = player.yaw; // should already be in yaw.
+                            const yawRad = Math.PI - player.yaw; // should already be in yaw. MINEFLAYER SPECIFC CHANGE, MATH.PI -
                             // potential inconsistency here. This may not be accurate.
-                            player.vel.x -= Math.fround(Math.sin(yawRad)) * 0.2;
-                            player.vel.z += Math.fround(Math.cos(yawRad)) * 0.2;
+                            const offsetX = Math.fround(Math.sin(yawRad)) * 0.2;
+                            const offsetZ = Math.fround(Math.cos(yawRad)) * 0.2;
+                            player.vel.x -= offsetX;
+                            player.vel.z += offsetZ;
                         }
                     }
                     else {
@@ -711,7 +710,7 @@ class BotcraftPhysics {
                         if (jumpPower > 1e-5) {
                             player.vel.y = jumpPower;
                             if (player.sprinting) {
-                                const yawRad = player.yaw; // should already be in yaw.
+                                const yawRad = Math.PI - player.yaw; // should already be in yaw. MINEFLAYER SPECIFC CHANGE, MATH.PI -
                                 player.vel.x -= Math.sin(yawRad) * 0.2;
                                 player.vel.z += Math.cos(yawRad) * 0.2;
                             }
@@ -893,7 +892,18 @@ class BotcraftPhysics {
                 const inertia = player.onGround ? friction * ctx.airborneInertia : ctx.airborneInertia;
                 // deviation, adding additional logic for changing attribute values.
                 const movementSpeedAttr = this.getMovementSpeedAttribute(ctx);
-                const inputStrength = player.onGround ? movementSpeedAttr * (0.21600002 / (friction * friction * friction)) : 0.02;
+                let inputStrength;
+                if (player.onGround) {
+                    inputStrength = movementSpeedAttr * (0.21600002 / (friction * friction * friction));
+                }
+                else {
+                    inputStrength = 0.02;
+                    // DEVIATION: taken from p-physics, fixes motion!
+                    if (player.control.sprint) {
+                        const airSprintFactor = ctx.airborneAccel * 0.3;
+                        inputStrength += airSprintFactor;
+                    }
+                }
                 this.applyInputs(inputStrength, player);
                 if (player.onClimbable) {
                     // LivingEntity::handleOnClimbable
@@ -941,9 +951,9 @@ class BotcraftPhysics {
             player.stuckSpeedMultiplier.set(0, 0, 0);
             player.vel.set(0, 0, 0);
         }
-        let maxStepUp = ctx.stepHeight;
+        let maxUpStep = ctx.stepHeight;
         if (!this.verLessThan("1.20.5")) {
-            maxStepUp = player.attributes[this.stepHeightAttribute].value;
+            maxUpStep = player.attributes[this.stepHeightAttribute].value;
         }
         // const playerAABB = player.getBB();
         if (!player.flying && movement.y <= 0.0 && player.control.sneak && player.onGround) {
@@ -955,58 +965,48 @@ class BotcraftPhysics {
                 bb.expand(-1e-7, -1e-7, -1e-7);
                 return bb;
             };
-            while (movement.x != 0.0 && this.worldIsFree(world, prepare(movement.x, -maxStepUp, 0), false)) {
+            while (movement.x != 0.0 && this.worldIsFree(world, prepare(movement.x, -maxUpStep, 0), false)) {
                 movement.x = movement.x < step && movement.x >= -step ? 0.0 : movement.x > 0.0 ? movement.x - step : movement.x + step;
             }
-            while (movement.z != 0.0 && this.worldIsFree(world, prepare(0, -maxStepUp, movement.z), false)) {
+            while (movement.z != 0.0 && this.worldIsFree(world, prepare(0, -maxUpStep, movement.z), false)) {
                 movement.z = movement.z < step && movement.z >= -step ? 0.0 : movement.z > 0.0 ? movement.z - step : movement.z + step;
             }
-            while ((movement.x != 0.0 && movement.z != 0.0 && prepare(movement.x, -maxStepUp, movement.z), false)) {
+            while ((movement.x != 0.0 && movement.z != 0.0 && prepare(movement.x, -maxUpStep, movement.z), false)) {
                 movement.x = movement.x < step && movement.x >= -step ? 0.0 : movement.x > 0.0 ? movement.x - step : movement.x + step;
                 movement.z = movement.z < step && movement.z >= -step ? 0.0 : movement.z > 0.0 ? movement.z - step : movement.z + step;
             }
         }
         const movementBeforeCollisions = movement.clone();
-        {
-            // Entity::collide
-            if (Math.pow(movement.norm(), 2) != 0.0) {
-                const playerAABB = player.getBB();
-                movement = this.collideBoundingBox(world, playerAABB, movement);
-            }
-            // Step up if block height delta is < max_up_step
-            // If already on ground (or collided with the ground while moving down) and horizontal collision
-            // TODO: changed in 1.21, check if this is still accurate
-            if ((player.onGround || (movement.y != movementBeforeCollisions.y && movementBeforeCollisions.y < 0.0)) &&
-                (movement.x != movementBeforeCollisions.x || movement.z != movementBeforeCollisions.z)) {
-                let movementWithStepUp = this.collideBoundingBox(world, player.getBB(), new vec3_1.Vec3(movementBeforeCollisions.x, maxStepUp, movementBeforeCollisions.z));
-                const horizontalMovement = new vec3_1.Vec3(movementBeforeCollisions.x, 0, movementBeforeCollisions.z);
-                // TODO: this code might straight up be wrong. It looks wrong. But the way they wrote it is so awkward.
-                // update: is he trying to offset a change with these 0.5s?
-                // const stepUpBB = player.getBB();
-                // stepUpBB.translate(horizontalMovement.x * 0.5, 0, horizontalMovement.z * 0.5);
-                // stepUpBB.expand(horizontalMovement.x, 0, horizontalMovement.z);
-                // stepUpBB.translate(0, maxStepUp, 0);
-                // const movementStepUpOnly = this.collideBoundingBox(world, stepUpBB, horizontalMovement);
-                const movementStepUpOnly = this.collideBoundingBox(world, player.getBB(), new vec3_1.Vec3(0, maxStepUp, 0));
-                if (movementStepUpOnly.y < maxStepUp) {
-                    const check = this.collideBoundingBox(world, player.getBB().translateVec(movementStepUpOnly), horizontalMovement).plus(movementStepUpOnly);
-                    if (check.x * check.x + check.z * check.z >
-                        movementWithStepUp.x * movementWithStepUp.x + movementWithStepUp.z * movementWithStepUp.z) {
-                        movementWithStepUp = check;
+        { // Entity::collide
+            const playerAABB = player.getBB();
+            const hDist = (vec) => Math.sqrt(vec.x * vec.x + vec.z * vec.z);
+            // const entityCollisions = world.getEntityCollisions(player, playerAABB.expand(movement));
+            let newMovement = Math.pow(movement.norm(), 2) === 0 ? movement : this.collideBoundingBox(world, playerAABB, movement);
+            const collisionX = Math.abs(movement.x - newMovement.x) > 1e-7;
+            const collisionY = Math.abs(movement.y - newMovement.y) > 1e-7;
+            const collisionZ = Math.abs(movement.z - newMovement.z) > 1e-7;
+            const onGround = player.onGround || (collisionY && movement.y < 0);
+            if (maxUpStep > 0 && onGround && (collisionX || collisionZ)) {
+                let stepUpMovement = this.collideBoundingBox(world, playerAABB, new vec3_1.Vec3(movement.x, maxUpStep, movement.z));
+                const stepOnlyMovement = this.collideBoundingBox(world, playerAABB.expandTowardsCoords(movement.x, 0, movement.z), new vec3_1.Vec3(0, maxUpStep, 0));
+                if (stepOnlyMovement.y < maxUpStep) {
+                    const adjustedStepUp = this.collideBoundingBox(world, playerAABB.translateVec(stepOnlyMovement), new vec3_1.Vec3(movement.x, 0, movement.z)).add(stepOnlyMovement);
+                    if (hDist(adjustedStepUp) > hDist(stepUpMovement)) {
+                        stepUpMovement = adjustedStepUp;
                     }
                 }
-                if (movementWithStepUp.x * movementWithStepUp.x + movementWithStepUp.z * movementWithStepUp.z >
-                    movement.x * movement.x + movement.z * movement.z) {
-                    movement = movementWithStepUp.plus(this.collideBoundingBox(world, player.getBB().translateVec(movementWithStepUp), new vec3_1.Vec3(0.0, -movementWithStepUp.y + movementBeforeCollisions.y, 0.0)));
+                if (hDist(stepUpMovement) > hDist(newMovement)) {
+                    newMovement = stepUpMovement.add(this.collideBoundingBox(world, playerAABB.translateVec(stepUpMovement), new vec3_1.Vec3(0, -stepUpMovement.y + movement.y, 0)));
                 }
             }
+            movement = newMovement;
         }
         if (Math.pow(movement.norm(), 2) > 1e-7) {
             player.pos.add(movement);
         }
-        const collisionX = movement.x != movementBeforeCollisions.x;
-        const collisionY = movement.y != movementBeforeCollisions.y;
-        const collisionZ = movement.z != movementBeforeCollisions.z;
+        const collisionX = Math.abs(movement.x - movementBeforeCollisions.x) > 1e-7;
+        const collisionY = Math.abs(movement.y - movementBeforeCollisions.y) > 1e-7;
+        const collisionZ = Math.abs(movement.z - movementBeforeCollisions.z) > 1e-7;
         player.isCollidedHorizontally = collisionX || collisionZ;
         player.isCollidedVertically = collisionY;
         // TODO: add minor horizontal collision check
@@ -1135,27 +1135,99 @@ class BotcraftPhysics {
             }
         }
     }
-    collideBoundingBox(world, bb, movement) {
-        // BIG DEVIATION.
-        const newBB = bb.clone();
-        // newBB.translateVec(movement);
-        const colliders = this.getSurroundingBBs(newBB, world);
+    collideBoundingBox(world, bb, movement, colliders = []) {
+        const queryBB = bb.clone().expandTowards(movement);
+        const combinedColliders = [...colliders];
+        const blockCollisions = this.getSurroundingBBs(queryBB, world);
+        for (const block of blockCollisions) {
+            combinedColliders.push(block);
+        }
+        return this.collideWithShapes(movement, bb, combinedColliders);
+    }
+    collideWithShapes(movement, bb, colliders = []) {
         if (colliders.length === 0) {
             return movement;
         }
-        let collidedMovement = movement;
-        let movedAABB = newBB.clone();
-        this.collideOneAxis(movedAABB, collidedMovement, 1, colliders);
-        // collision on X before Z
-        if (Math.abs(collidedMovement.x) > Math.abs(collidedMovement.z)) {
-            this.collideOneAxis(movedAABB, collidedMovement, 0, colliders);
-            this.collideOneAxis(movedAABB, collidedMovement, 2, colliders);
+        let dx = movement.x;
+        let dy = movement.y;
+        let dz = movement.z;
+        if (dy !== 0.0) {
+            dy = this.shapeCollide(1, bb, colliders, dy);
+            if (dy !== 0.0) {
+                bb = bb.translate(0, dy, 0);
+            }
         }
-        else {
-            this.collideOneAxis(movedAABB, collidedMovement, 2, colliders);
-            this.collideOneAxis(movedAABB, collidedMovement, 0, colliders);
+        const prioritizeZ = Math.abs(dx) < Math.abs(dz);
+        if (prioritizeZ && dz !== 0.0) {
+            dz = this.shapeCollide(2, bb, colliders, dz);
+            if (dz !== 0.0) {
+                bb = bb.translate(0, 0, dz);
+            }
+        }
+        if (dx !== 0.0) {
+            dx = this.shapeCollide(0, bb, colliders, dx);
+            if (!prioritizeZ && dx !== 0.0) {
+                bb = bb.translate(dx, 0, 0);
+            }
+        }
+        if (!prioritizeZ && dz !== 0.0) {
+            dz = this.shapeCollide(2, bb, colliders, dz);
+        }
+        return new vec3_1.Vec3(dx, dy, dz);
+    }
+    shapeCollide(axis, bb, colliders, movement) {
+        if (Math.abs(movement) < 1e-7) {
+            return 0.0;
+        }
+        movement = this.voxelShapeCollide(axis, bb, movement, colliders);
+        return movement;
+    }
+    voxelShapeCollide(axis, bb, movement, colliders) {
+        if (Math.abs(movement) < 1e-7) {
+            return 0.0;
+        }
+        const [minBB, maxBB] = bb.minAndMaxArrays();
+        const maxAxis = axis === 0 ? bb.maxX : axis === 1 ? bb.maxY : bb.maxZ;
+        const minAxis = axis === 0 ? bb.minX : axis === 1 ? bb.minY : bb.minZ;
+        const offAxis1 = (axis + 1) % 3;
+        const offAxis2 = (axis + 2) % 3;
+        if (movement > 0.0) {
+            for (const collider of colliders) {
+                const colliderMin = axis === 0 ? collider.minX : axis === 1 ? collider.minY : collider.minZ;
+                // verify that the other axis are colliding.
+                const [minPt, maxPt] = collider.minAndMaxArrays();
+                if (maxBB[offAxis1] - 1e-7 <= minPt[offAxis1] || minBB[offAxis1] + 1e-7 >= maxPt[offAxis1] ||
+                    maxBB[offAxis2] - 1e-7 <= minPt[offAxis2] || minBB[offAxis2] + 1e-7 >= maxPt[offAxis2]) {
+                    continue;
+                }
+                if (colliderMin >= maxAxis) {
+                    const distance = colliderMin - maxAxis;
+                    if (distance >= -1e-7) {
+                        movement = Math.min(movement, distance);
+                    }
+                    // return movement;
+                }
+            }
+        }
+        else if (movement < 0.0) {
+            for (const collider of colliders) {
+                // verify that the other axis are colliding.
+                const [minPt, maxPt] = collider.minAndMaxArrays();
+                if (maxBB[offAxis1] - 1e-7 <= minPt[offAxis1] || minBB[offAxis1] + 1e-7 >= maxPt[offAxis1] ||
+                    maxBB[offAxis2] - 1e-7 <= minPt[offAxis2] || minBB[offAxis2] + 1e-7 >= maxPt[offAxis2]) {
+                    continue;
+                }
+                const colliderMax = axis === 0 ? collider.maxX : axis === 1 ? collider.maxY : collider.maxZ;
+                if (colliderMax <= minAxis) {
+                    const distance = colliderMax - minAxis;
+                    if (distance <= 1e-7) {
+                        movement = Math.max(movement, distance);
+                    }
+                    // return movement;
+                }
+            }
         }
-        return collidedMovement;
+        return movement;
     }
     collideOneAxis(movedAABB, movement, axis, colliders) {
         const minAABB = movedAABB.minPoint().toArray();
@@ -1172,17 +1244,6 @@ class BotcraftPhysics {
             const maxCollider = collider.maxPoint().toArray();
             const cond1 = movementLst[thisAxis] > 0.0 && maxAABB[thisAxis] - 1e-7 <= minCollider[thisAxis];
             const cond2 = movementLst[thisAxis] < 0.0 && minAABB[thisAxis] + 1e-7 >= maxCollider[thisAxis];
-            // if (collider.minY === 5 && thisAxis === 2) {
-            //   console.log("collider", collider);
-            //   console.log("movement", movement);
-            //   console.log("movedAABB", movedAABB);
-            //   console.log("movementLst", movementLst);
-            //   console.log(minCollider, maxCollider);
-            //   console.log(minAABB, maxAABB);
-            //   console.log("axis", thisAxis);
-            //   console.log(movementLst[thisAxis], maxAABB[thisAxis] - 1e-7, minCollider[thisAxis], cond1);
-            //   console.log(movementLst[thisAxis], minAABB[thisAxis] + 1e-7, maxCollider[thisAxis], cond2);
-            // }
             if (maxAABB[axis1] - 1e-7 > minCollider[axis1] &&
                 minAABB[axis1] + 1e-7 < maxCollider[axis1] &&
                 maxAABB[axis2] - 1e-7 > minCollider[axis2] &&
@@ -1211,7 +1272,7 @@ class BotcraftPhysics {
         if (sqrNorm > 1) {
             inputVector.normalize();
         }
-        inputVector.scale(inputStrength / Math.max(1, sqrNorm));
+        inputVector.scale(inputStrength);
         const yaw = Math.PI - player.yaw;
         const sinYaw = Math.sin(yaw);
         const cosYaw = Math.cos(yaw);

package/dist/physics/engines/entityPhysics.js

@@ -620,6 +620,7 @@ class EntityPhysics {
                 else
                     vel.y -= entity.gravity * gravityMultiplier;
             }
+            console.log(dragOrFriction);
             vel.x *= dragOrFriction;
             vel.z *= dragOrFriction;
         }

package/dist/physics/states/playerState.js

@@ -432,6 +432,7 @@ class PlayerState {
         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;
+        console.log(this.yaw, this.pitch);
     }
     look(yaw, pitch) {
         this.yaw = yaw;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nxg-org/mineflayer-physics-util",
-    "version": "1.7.8",
+    "version": "1.7.10",
     "description": "Provides functionality for more accurate entity and projectile tracking.",
     "keywords": [
         "mineflayer",

package/tests/actualBot.ts

@@ -1,141 +1,183 @@
 import { pathfinder, goals } from "mineflayer-pathfinder";
 import { Bot, createBot } from "mineflayer";
-const physicsInject = require("mineflayer/lib/plugins/physics")
+const physicsInject = require("mineflayer/lib/plugins/physics");
 import loader, { BotcraftPhysics, EntityPhysics, EntityState, EPhysicsCtx } from "../src/index";
 import { PlayerState } from "../src/physics/states";
 
 const { Physics } = require("prismarine-physics");
 
-const bot: Bot = createBot({
-  host: process.argv[2],
-  port: Number(process.argv[3]),
-  username: "testingbot",
-  version: process.argv[4],
-});
-
-bot.once("spawn", async () => {
-  bot.loadPlugin(loader);
-  bot.loadPlugin(pathfinder);
-  await bot.waitForTicks(20);
-  (bot as any).physics.yawSpeed = 50;
-  (bot as any).physics.pitchSpeed = 50;
-  // setupNewPhysics(bot);
-});
-
 const rl = require("readline").createInterface({
   input: process.stdin,
   output: process.stdout,
 });
 
-rl.on("line", (line: any) => bot.chat(line));
 
-// print whenever bot hits the ground
-
-let wasOnGround = false;
-let printNextPos = false;
-bot.on("move", (pos) => {
-  if (bot.entity.onGround && !wasOnGround) {
-    bot.chat("Hit the ground! " + bot.entity.position.toString());
+let bot1: Bot;
+function buildBot() {
+  console.log('hey!')
+
+  const bot = createBot({
+    host: process.argv[2],
+    port: Number(process.argv[3]),
+    username: "testingbot",
+    version: process.argv[4],
+  });
+
+  bot.once("spawn", async () => {
+    bot.loadPlugin(loader);
+    bot.loadPlugin(pathfinder);
+    await bot.waitForTicks(20);
+    (bot as any).physics.yawSpeed = 50;
+    (bot as any).physics.pitchSpeed = 50;
+    // setupNewPhysics(bot);
+  });
+
+  let wasOnGround = false;
+  let printNextPos = false;
+
+  bot.on("move", (pos) => {
+    // console.log(pos);
+    if (bot.entity.onGround && !wasOnGround) {
+      // bot.chat("Hit the ground! " + bot.entity.position.toString());
+    }
+    wasOnGround = bot.entity.onGround;
+  });
+
+  // print whenever another player hits the ground
+  let lastPositions: Record<string, boolean> = {};
+  bot.on("entityMoved", (entity) => {
+    if (entity.username && entity.username !== bot.username) {
+      // check by seeing is y value is an integer
+      if (Math.floor(entity.position.y) === entity.position.y && !lastPositions[entity.username]) {
+        // check if in liquid
+        const block = bot.blockAt(entity.position);
+        if (block && (block.type === bot.registry.blocksByName.water.id || block.type === bot.registry.blocksByName.lava.id)) return;
+
+        bot.chat(`${entity.username} hit the ground! ${entity.position.toString()}`);
+        lastPositions[entity.username] = true;
+      } else if (Math.floor(entity.position.y) !== entity.position.y) {
+        lastPositions[entity.username] = false;
+      }
+    }
+  });
+
+  let usingNew = false;
+  let oldSimulate: any = null;
+
+  function setupNewPhysics(bot: Bot) {
+    if (usingNew) return;
+    usingNew = true;
+    oldSimulate = (bot.physics as any).simulatePlayer;
+
+    const val = new BotcraftPhysics(bot.registry);
+
+    (EntityState.prototype as any).apply = function (this: EntityState, bot: Bot) {
+      // console.log(this.control, this.isUsingItem);
+      this.applyToBot(bot);
+    };
+
+    const ctx = EPhysicsCtx.FROM_BOT(val, bot);
+    const state = ctx.state as PlayerState;
+
+    // EntityPhysics.prototype.simulate = function (ctx, world) {
+    //   bot.physics.simulatePlayer(ctx.state, world);
+    // }
+
+    (bot.physics as any).autojumpCooldown = 0;
+    // (bot.physics).jumpTicks = 0;
+
+    (bot.physics as any).simulatePlayer = (...args: any[]) => {
+      state.update(bot);
+      ctx.state.jumpTicks = 0; // allow immediate jumping
+      return val.simulate(ctx, bot.world);
+    };
   }
-  wasOnGround = bot.entity.onGround;
-});
-
-// print whenever another player hits the ground
-let lastPositions: Record<string, boolean> = {};
-bot.on("entityMoved", (entity) => {
-  if (entity.username && entity.username !== bot.username) {
-    // check by seeing is y value is an integer
-    if (Math.floor(entity.position.y) === entity.position.y && !lastPositions[entity.username]) {
-
-      // check if in liquid
-      const block = bot.blockAt(entity.position);
-      if (block && (block.type === bot.registry.blocksByName.water.id || block.type === bot.registry.blocksByName.lava.id)) return;
-
-      bot.chat(`${entity.username} hit the ground! ${entity.position.toString()}`);
-      lastPositions[entity.username] = true;
-    } else if (Math.floor(entity.position.y) !== entity.position.y) {
-      lastPositions[entity.username] = false;
-    }}
-});
 
-function setupNewPhysics(bot: Bot) {
-  const val = new BotcraftPhysics(bot.registry);
-
-      (EntityState.prototype as any).apply = function (this: EntityState, bot: Bot) {
-        // console.log(this.control, this.isUsingItem);
-        this.applyToBot(bot);
-      };
-
-      const ctx = EPhysicsCtx.FROM_BOT(val, bot);
-      const state = ctx.state as PlayerState
+  bot.on("chat", async (user, message) => {
+    const [cmd, ...args] = message.split(" ");
+    const author = bot.nearestEntity((e) => e.username === user);
+
+    switch (cmd) {
+      case "using":
+        bot.chat(`Using new physics: ${usingNew}`);
+        break;
+      case "lookatme":
+        if (!author) return bot.chat("I can't see you!");
+        bot.lookAt(author.position.offset(0, author.height, 0));
+        break;
+      case "status":
+        const str = `onGround: ${bot.entity.onGround}, hCol:${(bot.entity as any).isCollidedHorizontally}, vCol:${
+          (bot.entity as any).isCollidedVertically
+        }, inWater:${(bot.entity as any).isInWater}, inLava:${(bot.entity as any).isInLava}`;
+        bot.chat(str);
+        break;
+      case "use":
+        if (bot.usingHeldItem) bot.deactivateItem();
+        else bot.activateItem();
+        break;
+      case "useoff":
+        bot.deactivateItem();
+        bot.activateItem(true);
+        break;
+      case "control":
+        if (args[0] === "clear") return bot.clearControlStates();
+        if (args.length === 1) return bot.setControlState(args[0] as any, !bot.getControlState(args[0] as any));
+        bot.setControlState(args[0] as any, args[1] === "true");
+        break;
+      case "sim":
+        // turn all but the mentioned ones off
+        const [time, ...controls] = args;
+        bot.clearControlStates();
+        for (const control of controls) {
+          bot.setControlState(control as any, true);
+        }
+
+        for (let i = 0; i <= Number(time); i++) {
+          console.log(bot.entity.position, bot.entity.velocity, i);
+          await bot.waitForTicks(1);
+        }
+        bot.clearControlStates();
+
+        break;
+      case "reset":
+        usingNew = false;
+        bot.quit();
+        await new Promise((res) => setTimeout(res, 3000));
+        bot1 = buildBot();
+       
+        break;
+      case "new":
+        setupNewPhysics(bot);
+        bot.chat("Switched to new physics!");
+        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);
+        bot.pathfinder.setGoal(goal0);
+        break;
+      case "goto":
+        if (!author) return bot.chat(`Cannot see ${user}!`);
+        const goal1 = new goals.GoalNear(Number(args[0]), Number(args[1]), Number(args[2]), 3);
+        bot.pathfinder.setGoal(goal1);
+        break;
+      case "stop":
+        bot.deactivateItem();
+        bot.pathfinder.stop();
+        bot.clearControlStates();
+        bot.chat("Stopped!");
+        break;
+    }
+  });
+
+  
+  rl.on("line", (line: any) => bot.chat(line));
+
+  return bot;
+}
 
-      // EntityPhysics.prototype.simulate = function (ctx, world) {
-      //   bot.physics.simulatePlayer(ctx.state, world);
-      // }
 
-      (bot.physics as any).autojumpCooldown = 0;
-      // (bot.physics).jumpTicks = 0;
 
-      (bot.physics as any).simulatePlayer = (...args: any[]) => {
-        state.update(bot);
-        ctx.state.jumpTicks = 0; // allow immediate jumping
-        return val.simulate(ctx, bot.world);
-      };
-}
-
-bot.on("chat", (user, message) => {
-  const [cmd, ...args] = message.split(" ");
-  const author = bot.nearestEntity((e) => e.username === user);
-
-  switch (cmd) {
-    case "lookatme":
-      if (!author) return bot.chat("I can't see you!");
-      bot.lookAt(author.position.offset(0, author.height, 0));
-      break;
-    case "status":
-      const str = `onGround: ${bot.entity.onGround}, hCol:${(bot.entity as any).isCollidedHorizontally}, vCol:${(bot.entity as any).isCollidedVertically}, inWater:${(bot.entity as any).isInWater}, inLava:${(bot.entity as any).isInLava}`;
-      bot.chat(str);
-      break
-    case "use":
-      if (bot.usingHeldItem) bot.deactivateItem();
-      else bot.activateItem();
-      break;
-    case "useoff":
-      bot.deactivateItem()
-      bot.activateItem(true)
-      break
-    case "control":
-     
-      if (args[0] === "clear") return bot.clearControlStates();
-      if (args.length !== 2) return bot.chat("Invalid control command!");
-      bot.setControlState(args[0] as any, args[1] === "true");
-      break;
-    case "original":
-      bot.loadPlugin(physicsInject);
-      bot.chat("Switched to original physics!");
-      break;
-    case "new":
-      setupNewPhysics(bot);
-      bot.chat("Switched to new physics!");
-      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);
-      bot.pathfinder.setGoal(goal0);
-      break;
-    case "goto":
-      if (!author) return bot.chat(`Cannot see ${user}!`);
-      const goal1 = new goals.GoalNear(Number(args[0]), Number(args[1]), Number(args[2]), 3);
-      bot.pathfinder.setGoal(goal1);
-      break;
-    case "stop":
-      bot.deactivateItem();
-      bot.pathfinder.stop();
-      bot.clearControlStates();
-      bot.chat("Stopped!");
-      break;
-  }
-});
+bot1 = buildBot();

package/tests/fakeWorld.test.ts

@@ -13,10 +13,11 @@ import { Bot, ControlState } from "mineflayer";
 
 const version = "1.12.2";
 const mcData = md(version);
+const Engine = BotcraftPhysics;
 const Block = block(version) as typeof PBlock;
 
-const groundLevel = 4;
-const floatingOffset = 20;
+const groundLevel = 67;
+const floatingOffset = 100 - groundLevel;
 const control: { [key: string]: boolean } = {};
 
 class FakeWorld {
@@ -47,12 +48,13 @@ class FakeWorld {
   }
 }
 
-function createFakePlayer(pos: Vec3, groundLevel: number) {
+function createFakePlayer(pos: Vec3, tmpGroundLevel: number = groundLevel) {
+  const onGround = pos.y === tmpGroundLevel
   return {
     entity: {
       position: pos,
-      velocity: new Vec3(0, -0.08, 0),
-      onGround: pos.y === groundLevel,
+      velocity: new Vec3(0, onGround ? -0.08 : 0, 0),
+      onGround: onGround,
       isInWater: false,
       isInLava: false,
       isInWeb: false,
@@ -94,7 +96,7 @@ describe("Physics Simulation Tests", () => {
   const setupEntity = (yOffset: number) => {
     fakePlayer = createFakePlayer(new Vec3(0, groundLevel + yOffset, 0), groundLevel);
     fakePlayer.entity = applyMdToNewEntity(EPhysicsCtx, playerType, fakePlayer.entity);
-    physics = new BotcraftPhysics(mcData);
+    physics = new Engine(mcData);
     playerCtx = EPhysicsCtx.FROM_BOT(physics, fakePlayer);
     playerState = playerCtx.state as PlayerState;
     playerState.control = ControlStateHandler.DEFAULT();
@@ -110,7 +112,7 @@ describe("Physics Simulation Tests", () => {
     playerState.vel.y = 0;
     playerCtx.gravity = 0;
 
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 2; i++) {
       // playerState.update(fakePlayer);
       physics.simulate(playerCtx, fakeWorld);
       playerState.apply(fakePlayer);
@@ -127,6 +129,7 @@ describe("Physics Simulation Tests", () => {
     for (let i = 0; i < 10; i++) {
       physics.simulate(playerCtx, fakeWorld);
       playerState.apply(fakePlayer);
+      // console.log(fakePlayer.entity.position, playerState.pos, playerState.vel, playerState.age)
     }
 
     if (playerState.control.forward) {
@@ -136,10 +139,10 @@ describe("Physics Simulation Tests", () => {
     }
   });
 
-  it("test sprint-jumping", () => {
+  it("sprint-jumping", () => {
     setupEntity(0);
     playerState.control.forward = true;
-    // playerState.control.sprint = true;
+    playerState.control.sprint = true;
 
     for (let i = 0; i < 4; i++) {
       physics.simulate(playerCtx, fakeWorld);
@@ -156,37 +159,39 @@ describe("Physics Simulation Tests", () => {
     }
 
     expect(fakePlayer.entity.position.y).toEqual(groundLevel);
-    expect(fakePlayer.entity.position.z).toEqual(-2.610639097306083);
+    expect(fakePlayer.entity.position.z).toEqual(-4.085029471928113);
   });
 
-  it("falling movement speed", () => {
+  it("walk_fallspeed", () => {
     setupEntity(floatingOffset);
     playerState.control.forward = true;
 
     while (!fakePlayer.entity.onGround && playerState.age < 100) {
       physics.simulate(playerCtx, fakeWorld);
+      // console.log(fakePlayer.entity.position, playerState.pos, playerState.vel, playerState.age)
       playerState.apply(fakePlayer);
     }
 
+    expect(fakePlayer.entity.position.z).toEqual(-5.082680598494437);
     expect(fakePlayer.entity.position.y).toEqual(groundLevel);
-    expect(fakePlayer.entity.position.z).toEqual(-3.253675739201285);
-
-    const landingPos = playerState.pos.clone();
+  });
 
+  it ("sprint_fallspeed", () => {
     setupEntity(floatingOffset);
     playerState.control.forward = true;
     playerState.control.sprint = true;
 
+    // console.log(playerState.vel)
     while (!fakePlayer.entity.onGround && playerState.age < 100) {
       physics.simulate(playerCtx, fakeWorld);
       playerState.apply(fakePlayer);
     }
 
-    console.log(fakePlayer.entity.position, landingPos, playerState.pos)
+    // console.log(fakePlayer.entity.position, landingPos, playerState.pos, playerState.control)
 
+    expect(fakePlayer.entity.position.z).toEqual(-7.624010798740387);
     expect(fakePlayer.entity.position.y).toEqual(groundLevel);
-    expect(fakePlayer.entity.position).toEqual(landingPos);
-  });
+  })
 
   it("should restore position after gravity toggle", () => {
     setupEntity(floatingOffset);
@@ -219,7 +224,7 @@ describe("Physics Simulation Tests", () => {
       playerState.apply(fakePlayer);
     }
 
-    expect(fakePlayer.entity.position.y).toEqual(5.001335979112147);
+    expect(fakePlayer.entity.position.y).toEqual(groundLevel + 1.001335979112147);
 
     for (let i = 0; i < 9; i++) {
       physics.simulate(playerCtx, fakeWorld);
@@ -229,18 +234,71 @@ describe("Physics Simulation Tests", () => {
     expect(fakePlayer.entity.position.y).toEqual(groundLevel);
   });
 
-  it("horizonal collision detection", () => {
+  it("hCol-z", () => {
     setupEntity(0);
-    fakeWorld.setOverrideBlock(new Vec3(0, groundLevel + 1, -2), mcData.blocksByName.stone.id);
+    const blockPos = new Vec3(0, groundLevel + 1, -2);
+    fakeWorld.setOverrideBlock(blockPos, mcData.blocksByName.dirt.id);
+    playerState.look(0, 0);
     playerState.control.forward = true;
 
     for (let i = 0; i < 10; i++) {
       physics.simulate(playerCtx, fakeWorld);
       playerState.apply(fakePlayer);
-      // console.log(fakePlayer.entity.position, playerState.isCollidedHorizontally);
+      console.log(fakePlayer.entity.position, playerState.isCollidedHorizontally);
     }
 
     expect(playerState.pos.z).toEqual(-0.7);
     expect(playerState.isCollidedHorizontally).toEqual(true);
   });
+
+  it("hCol--z", () => {
+    setupEntity(0);
+    const blockPos = new Vec3(0, groundLevel + 1, 1);
+    fakeWorld.setOverrideBlock(blockPos, mcData.blocksByName.dirt.id);
+    playerState.look(-359.9999 * (Math.PI / 360), 0);
+    playerState.control.forward = true;
+
+    for (let i = 0; i < 10; i++) {
+      physics.simulate(playerCtx, fakeWorld);
+      playerState.apply(fakePlayer);
+      console.log(fakePlayer.entity.position, playerState.isCollidedHorizontally);
+    }
+
+    expect(playerState.pos.z).toEqual(0.7);
+    expect(playerState.isCollidedHorizontally).toEqual(true);
+  });
+
+  it("hCol--x", () => {
+    setupEntity(0);
+    const blockPos = new Vec3(-2, groundLevel + 1, 0);
+    fakeWorld.setOverrideBlock(blockPos, mcData.blocksByName.dirt.id);
+    playerState.look(180 * (Math.PI / 360), 0)
+    playerState.control.forward = true;
+
+    for (let i = 0; i < 10; i++) {
+      physics.simulate(playerCtx, fakeWorld);
+      playerState.apply(fakePlayer);
+      console.log(fakePlayer.entity.position, playerState.isCollidedHorizontally);
+    }
+
+    expect(playerState.pos.x).toEqual(-0.7);
+    expect(playerState.isCollidedHorizontally).toEqual(true);
+  });
+
+  it("hCol-x", () => {
+    setupEntity(0);
+    const blockPos = new Vec3(1, groundLevel + 1, 0);
+    fakeWorld.setOverrideBlock(blockPos, mcData.blocksByName.dirt.id);
+    playerState.look(-180 * (Math.PI / 360), 0);
+    playerState.control.forward = true;
+
+    for (let i = 0; i < 10; i++) {
+      physics.simulate(playerCtx, fakeWorld);
+      playerState.apply(fakePlayer);
+      console.log(fakePlayer.entity.position, playerState.isCollidedHorizontally);
+    }
+
+    expect(playerState.pos.x).toEqual(0.7);
+    expect(playerState.isCollidedHorizontally).toEqual(true);
+  });
 });