@nxg-org/mineflayer-physics-util 1.8.18 → 1.9.0

package/.vscode/settings.json

@@ -1,5 +1,5 @@
-{
-    "print.colourScheme": "GitHub",
-    "ecl.launchConfiguration": "not found",
-    "ecl.targetCluster": {}
+{
+    "print.colourScheme": "GitHub",
+    "ecl.launchConfiguration": "not found",
+    "ecl.targetCluster": {}
 }

package/README.md

@@ -1 +1 @@
-# mineflayer-physics-utils
+# mineflayer-physics-utils

package/dist/index.d.ts

@@ -14,4 +14,4 @@ export { EntityPhysics, BotcraftPhysics } from "./physics/engines";
 export { EntityState, PlayerState, PlayerPoses, IEntityState } from "./physics/states";
 export { ControlStateHandler } from "./physics/player";
 export type { SimulationGoal, Controller, OnGoalReachFunction } from "./simulators";
-export { convertPlayerState } from "./util/physicsUtils";
+export { convertPlayerState, applyToPlayerState } from "./util/physicsUtils";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertPlayerState = exports.ControlStateHandler = exports.PlayerPoses = exports.PlayerState = exports.EntityState = exports.BotcraftPhysics = exports.EntityPhysics = exports.BaseSimulator = exports.PhysicsWorldSettings = exports.EPhysicsCtx = void 0;
+exports.applyToPlayerState = exports.convertPlayerState = exports.ControlStateHandler = exports.PlayerPoses = exports.PlayerState = exports.EntityState = exports.BotcraftPhysics = exports.EntityPhysics = exports.BaseSimulator = exports.PhysicsWorldSettings = exports.EPhysicsCtx = void 0;
 exports.default = loader;
 exports.initSetup = initSetup;
 const settings_1 = require("./physics/settings");
@@ -30,3 +30,4 @@ var player_1 = require("./physics/player");
 Object.defineProperty(exports, "ControlStateHandler", { enumerable: true, get: function () { return player_1.ControlStateHandler; } });
 var physicsUtils_1 = require("./util/physicsUtils");
 Object.defineProperty(exports, "convertPlayerState", { enumerable: true, get: function () { return physicsUtils_1.convertPlayerState; } });
+Object.defineProperty(exports, "applyToPlayerState", { enumerable: true, get: function () { return physicsUtils_1.applyToPlayerState; } });

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

@@ -9,7 +9,9 @@ import { IEntityState } from "../states";
 import { IPhysics } from "./IPhysics";
 import { PlayerState } from "../states";
 import type { world } from "prismarine-world";
-type World = world.WorldSync;
+type World = {
+    getBlock: world.WorldSync["getBlock"];
+};
 /**
  * Looking at this code, it's too specified towards players.
  *
@@ -84,6 +86,7 @@ export declare class BotcraftPhysics implements IPhysics {
     getLiquidHeightPcent(block: Block): number;
     getRenderedDepth(block: Block): number;
     private updateSwimming;
+    private isMovingSlowly;
     private localPlayerAIStep;
     private inputsToCrouch;
     private isSwimmingAndNotFlying;
@@ -92,6 +95,8 @@ export declare class BotcraftPhysics implements IPhysics {
     private hasEnoughFoodToSprint;
     private vehicleCanSprint;
     private isSwimming;
+    private handleFallFlyingCollisions;
+    private applyFireworkBoost;
     private shouldStopRunSprinting;
     private shouldStopSwimSprinting;
     /**
@@ -102,6 +107,9 @@ export declare class BotcraftPhysics implements IPhysics {
     setSprinting(ctx: EPhysicsCtx, value: boolean): void;
     private inputsToFly;
     private inputsToJump;
+    private getBlockJumpFactor;
+    private getKnownJumpFactor;
+    private getOffGroundSpeed;
     private getBlockBelowAffectingMovement;
     /**
      * Taken from original physics impl.

package/dist/physics/engines/botcraft.js

@@ -451,8 +451,18 @@ class BotcraftPhysics {
                     !!(block.type === this.waterId || this.waterLike.has(block.type) || block.getProperties().waterlogged);
         }
     }
+    isMovingSlowly(ctx, world) {
+        const player = ctx.state;
+        if (this.verGreaterThan("1.13.2")) {
+            const visuallyCrawling = (player.pose === states_1.PlayerPoses.SWIMMING || (!player.fallFlying && player.pose === states_1.PlayerPoses.FALL_FLYING)) &&
+                !player.isInWater;
+            return player.crouching || visuallyCrawling;
+        }
+        return player.crouching;
+    }
     localPlayerAIStep(ctx, world) {
         const player = ctx.state;
+        const tickStartedOnGround = player.onGround;
         const heading = (0, states_1.convInpToAxes)(player);
         player.heading = heading;
         // moved into AiStep since it's tied to player behavior. Strictly, is Player::updateSwimming.
@@ -472,11 +482,6 @@ class BotcraftPhysics {
         {
             player.flyJumpTriggerTime = Math.max(0, player.flyJumpTriggerTime - 1);
         }
-        // TODO: find a good way to implement this.
-        player.prevHeading.forward = heading.forward;
-        player.prevHeading.strafe = heading.strafe;
-        player.prevControl.jump = player.control.jump;
-        player.prevControl.sneak = player.control.sneak;
         // livingEntity::AiStep
         {
             player.jumpTicks = Math.max(0, player.jumpTicks - 1);
@@ -509,6 +514,11 @@ class BotcraftPhysics {
                     player.vel.y += (mSinPitch - player.vel.y) * (mSinPitch < -0.2 ? 0.085 : 0.06);
                 }
             }
+            // Refresh pose before movement so the first fall-flying tick uses the
+            // correct collider instead of the standing bounding box.
+            if (this.verGreaterThan("1.13.2")) {
+                this.updatePoses(ctx, world);
+            }
             const velY = player.vel.y;
             this.movePlayer(ctx, world); // TODO: should be in player-specific logic??
             if (player.flying) {
@@ -527,6 +537,13 @@ class BotcraftPhysics {
         if (this.verGreaterThan("1.13.2")) {
             this.updatePoses(ctx, world);
         }
+        // Preserve the current inputs for the next tick after all previous-state
+        // consumers in this tick have already read the prior values.
+        player.lastOnGround = player.onGround;
+        player.prevHeading.forward = heading.forward;
+        player.prevHeading.strafe = heading.strafe;
+        player.prevControl.jump = player.control.jump;
+        player.prevControl.sneak = player.control.sneak;
     }
     inputsToCrouch(ctx, heading, world) {
         var _a, _b, _c;
@@ -545,19 +562,13 @@ class BotcraftPhysics {
             player.crouching = !this.isSwimmingAndNotFlying(ctx, world) && player.prevControl.sneak;
         }
         // Determine if moving slowly
-        let isMovingSlowly;
-        if (this.verGreaterThan("1.13.2")) {
-            isMovingSlowly = player.crouching || (player.pose === states_1.PlayerPoses.SWIMMING && !player.isInWater);
-        }
-        else {
-            isMovingSlowly = player.crouching;
-        }
+        const isMovingSlowly = this.isMovingSlowly(ctx, world);
         // Handle post-1.21.3 sprinting conditions
         if (this.verGreaterThan("1.21.3")) {
             // TODO: just use stored blindness effect.
             const hasBlindness = this.getEffectLevel(physicsUtils_1.CheapEffects.BLINDNESS, player.effects) > 0;
             // Stop sprinting when crouching fix in 1.21.4+
-            if (player.fallFlying || hasBlindness || isMovingSlowly) {
+            if (hasBlindness || isMovingSlowly) {
                 this.setSprinting(ctx, false);
             }
         }
@@ -640,6 +651,30 @@ class BotcraftPhysics {
         const player = ctx.state;
         return player.isInWater && player.isUnderWater;
     }
+    handleFallFlyingCollisions(player, previousHorizontalSpeed) {
+        if (!player.isCollidedHorizontally)
+            return;
+        const currentHorizontalSpeed = Math.sqrt(player.vel.x * player.vel.x + player.vel.z * player.vel.z);
+        const deltaSpeed = previousHorizontalSpeed - currentHorizontalSpeed;
+        const collisionDamage = deltaSpeed * 10.0 - 3.0;
+        if (collisionDamage > 0.0) {
+            // Vanilla applies fly-into-wall damage and sound here.
+            // BotcraftPhysics currently does not model those side effects.
+        }
+    }
+    applyFireworkBoost(player) {
+        if (player.fireworkRocketDuration <= 0)
+            return;
+        if (!player.fallFlying) {
+            player.fireworkRocketDuration = 0;
+            return;
+        }
+        const { lookDir } = (0, physicsUtils_1.getLookingVector)(player);
+        player.vel.x += lookDir.x * 0.1 + (lookDir.x * 1.5 - player.vel.x) * 0.5;
+        player.vel.y += lookDir.y * 0.1 + (lookDir.y * 1.5 - player.vel.y) * 0.5;
+        player.vel.z += lookDir.z * 0.1 + (lookDir.z * 1.5 - player.vel.z) * 0.5;
+        --player.fireworkRocketDuration;
+    }
     shouldStopRunSprinting(ctx, heading) {
         const player = ctx.state;
         return player.blindness > 0 ||
@@ -730,57 +765,68 @@ class BotcraftPhysics {
         var _a, _b;
         if (entity instanceof states_1.PlayerState) {
             const player = entity;
-            if (player.control.jump && !player.flying) {
-                if (player.isInWater || player.isInLava) {
-                    player.vel.y += 0.03999999910593033; // magic number
-                }
-                else if (player.onGround && player.jumpTicks === 0) {
-                    let blockJumpFactor = 1.0;
-                    const jumpBoost = 0.1 * player.jumpBoost; // in mineflayer, level 1 is 1, not 0.
-                    // get below block
-                    const blFeet = world.getBlock(new vec3_1.Vec3(player.pos.x, player.pos.y, player.pos.z));
-                    if (blFeet && this.honeyblockId !== blFeet.type) {
-                        const blBelow = world.getBlock(this.getBlockBelowAffectingMovement(player, world));
-                        if (blBelow && this.honeyblockId === blBelow.type) {
-                            blockJumpFactor = 0.4;
-                        }
-                    }
-                    else {
-                        blockJumpFactor = 0.4;
+            if (!player.control.jump) {
+                player.jumpTicks = 0;
+                return;
+            }
+            if (player.flying) {
+                return;
+            }
+            if (player.isInWater || player.isInLava) {
+                player.vel.y += 0.03999999910593033; // magic number
+            }
+            else if (player.onGround && player.jumpTicks === 0) {
+                const blockJumpFactor = this.getBlockJumpFactor(player, world, worldSettings);
+                const jumpBoost = Math.fround(0.1 * player.jumpBoost); // in mineflayer, level 1 is 1, not 0.
+                if (this.verLessThan("1.20.5")) {
+                    const jumpPower = Math.fround(Math.fround(0.42) * Math.fround(blockJumpFactor) + jumpBoost);
+                    player.vel.y = Math.max(jumpPower, player.vel.y);
+                    if (player.sprinting) {
+                        const yawRad = Math.PI - player.yaw; // should already be in yaw. MINEFLAYER SPECIFC CHANGE, MATH.PI -
+                        // potential inconsistency here. This may not be accurate.
+                        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;
                     }
-                    if (this.verLessThan("1.20.5")) {
-                        // console.log(blockJumpFactor)
-                        player.vel.y = Math.fround(0.42) * blockJumpFactor + jumpBoost;
+                }
+                else {
+                    const value = Math.fround((_b = (_a = entity.attributes[this.jumpStrengthAttribute]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : Math.fround(0.42));
+                    const jumpPower = Math.fround(value * Math.fround(blockJumpFactor) + jumpBoost);
+                    if (jumpPower > 1e-5) {
+                        player.vel.y = Math.max(jumpPower, player.vel.y);
                         if (player.sprinting) {
                             const yawRad = Math.PI - player.yaw; // should already be in yaw. MINEFLAYER SPECIFC CHANGE, MATH.PI -
-                            // potential inconsistency here. This may not be accurate.
-                            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;
+                            player.vel.x -= Math.sin(yawRad) * 0.2;
+                            player.vel.z += Math.cos(yawRad) * 0.2;
                         }
                     }
-                    else {
-                        // something about getting an attribute for jump strength?
-                        const value = (_b = (_a = entity.attributes[this.jumpStrengthAttribute]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : Math.fround(0.42); // default value from previous versions
-                        const jumpPower = value * blockJumpFactor + jumpBoost;
-                        if (jumpPower > 1e-5) {
-                            player.vel.y = jumpPower;
-                            if (player.sprinting) {
-                                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;
-                            }
-                        }
-                        player.jumpTicks = worldSettings.autojumpCooldown;
-                    }
-                }
-                else {
-                    player.jumpTicks = 0;
                 }
+                player.jumpTicks = worldSettings.autojumpCooldown;
             }
         }
     }
+    getBlockJumpFactor(entity, world, worldSettings) {
+        const feetBlock = world.getBlock(new vec3_1.Vec3(entity.pos.x, entity.pos.y, entity.pos.z));
+        const feetJumpFactor = this.getKnownJumpFactor(feetBlock === null || feetBlock === void 0 ? void 0 : feetBlock.type, worldSettings);
+        if (feetJumpFactor !== 1.0)
+            return feetJumpFactor;
+        const supportBlock = world.getBlock(this.getBlockBelowAffectingMovement(entity, world));
+        return this.getKnownJumpFactor(supportBlock === null || supportBlock === void 0 ? void 0 : supportBlock.type, worldSettings);
+    }
+    getKnownJumpFactor(blockType, worldSettings) {
+        if (blockType == null)
+            return 1.0;
+        if (blockType === this.honeyblockId)
+            return worldSettings.honeyblockJumpSpeed;
+        return 1.0;
+    }
+    getOffGroundSpeed(player) {
+        if (player.flying) {
+            return player.sprinting ? player.flySpeed * 2.0 : player.flySpeed;
+        }
+        return player.sprinting ? Math.fround(0.025999999) : Math.fround(0.02);
+    }
     getBlockBelowAffectingMovement(entity, world) {
         if (entity.supportingBlockPos != null) {
             return entity.supportingBlockPos; //.offset(0, -0.500001, 0);
@@ -929,6 +975,7 @@ class BotcraftPhysics {
             }
             // elytra flying.
             else if (player.fallFlying) {
+                const previousHorizontalSpeed = Math.sqrt(player.vel.x * player.vel.x + player.vel.z * player.vel.z);
                 // slight deviation
                 // sqrt(front_vector.x² + front_vector.z²) to follow vanilla code
                 const { pitch, sinPitch, cosPitch, lookDir } = (0, physicsUtils_1.getLookingVector)(player);
@@ -942,10 +989,10 @@ class BotcraftPhysics {
                     player.vel.z += (lookDir.z * deltaSpeed) / cosPitchFromLength;
                     player.vel.y += deltaSpeed;
                 }
-                if (player.pitch < 0.0 && cosPitchFromLength > 0.0) {
-                    const deltaSpeed = hVel * -lookDir.y * 0.04;
-                    player.vel.x += (lookDir.x * deltaSpeed) / cosPitchFromLength;
-                    player.vel.z += (lookDir.z * deltaSpeed) / cosPitchFromLength;
+                if (player.pitch > 0.0 && cosPitchFromLength > 0.0) {
+                    const deltaSpeed = hVel * lookDir.y * 0.04;
+                    player.vel.x += (-lookDir.x * deltaSpeed) / cosPitchFromLength;
+                    player.vel.z += (-lookDir.z * deltaSpeed) / cosPitchFromLength;
                     player.vel.y += deltaSpeed * 3.2; // magic number
                 }
                 if (cosPitchFromLength > 0.0) {
@@ -956,44 +1003,24 @@ class BotcraftPhysics {
                 player.vel.z *= Math.fround(0.99); // magic number, this DEFINITELY should be replaced by a drag value.
                 player.vel.y *= Math.fround(0.98); // magic number, this DEFINITELY should be replaced by a drag value.
                 this.applyMovement(ctx, world);
-                if (player.onGround) {
-                    player.fallFlying = false;
-                }
-                // Potentially not the correct place for this logic, but it is easier to implement here for now. This is the firework boost from elytra flying.
-                if (player.fireworkRocketDuration > 0) {
-                    const { lookDir } = (0, physicsUtils_1.getLookingVector)(player);
-                    player.vel.x += lookDir.x * 0.1 + (lookDir.x * 1.5 - player.vel.x) * 0.5;
-                    player.vel.y += lookDir.y * 0.1 + (lookDir.y * 1.5 - player.vel.y) * 0.5;
-                    player.vel.z += lookDir.z * 0.1 + (lookDir.z * 1.5 - player.vel.z) * 0.5;
-                    --player.fireworkRocketDuration;
-                }
-                // we're on ground or in air, not flying.
+                this.handleFallFlyingCollisions(player, previousHorizontalSpeed);
             }
             else {
-                // clear firework boost if on ground or in air without flying, otherwise it can cause issues with movement.
-                if (player.fireworkRocketDuration > 0) {
-                    player.fireworkRocketDuration = 0;
-                }
                 const blockBelow = world.getBlock(this.getBlockBelowAffectingMovement(player, world));
                 // deviation. using our stores slipperiness values.
                 const friction = blockBelow
                     ? (_c = this.blockSlipperiness[blockBelow.type]) !== null && _c !== void 0 ? _c : ctx.worldSettings.defaultSlipperiness
                     : ctx.worldSettings.defaultSlipperiness;
                 // console.log(blockBelow.name, blockBelow.position, player.supportingBlockPos, friction)
-                const inertia = player.onGround ? friction * ctx.airborneInertia : ctx.airborneInertia;
+                const inertia = player.lastOnGround ? friction * ctx.airborneInertia : ctx.airborneInertia;
                 // deviation, adding additional logic for changing attribute values.
                 const movementSpeedAttr = this.getMovementSpeedAttribute(ctx);
                 let inputStrength;
-                if (player.onGround) {
+                if (player.lastOnGround) {
                     inputStrength = movementSpeedAttr * (0.21600002 / (friction * friction * friction));
                 }
                 else {
-                    inputStrength = 0.02;
-                    // DEVIATION: taken from p-physics, fixes motion!
-                    if (player.sprinting) {
-                        const airSprintFactor = ctx.airborneAccel * 0.3;
-                        inputStrength += airSprintFactor;
-                    }
+                    inputStrength = this.getOffGroundSpeed(player);
                 }
                 this.applyInputs(inputStrength, player);
                 if (player.onClimbable) {
@@ -1024,6 +1051,7 @@ class BotcraftPhysics {
                 // this can be generalized.
                 player.vel.y *= 0.9800000190734863;
             }
+            this.applyFireworkBoost(player);
         }
     }
     applyMovement(ctx, world) {
@@ -1120,8 +1148,11 @@ class BotcraftPhysics {
         // TODO: add minor horizontal collision check
         {
             // Entity::setOnGroundWithKnownMovement
-            player.onGround = movementBeforeCollisions.y < 0.0 && collisionY;
-            if (player.onGround) {
+            const wasOnGround = player.onGround;
+            const groundedByCollision = movementBeforeCollisions.y < 0.0 && collisionY;
+            const shouldCheckStandingSupport = wasOnGround && Math.abs(movementBeforeCollisions.y) <= 1e-7;
+            player.onGround = groundedByCollision;
+            if (player.onGround || shouldCheckStandingSupport) {
                 const halfWidth = player.halfWidth;
                 const feetSliceAABB = new mineflayer_util_plugin_1.AABB(player.pos.x - halfWidth, player.pos.y, player.pos.z - halfWidth, player.pos.x + halfWidth, player.pos.y + 1, player.pos.z + halfWidth);
                 const supportingBlockPos = this.getSupportingBlockPos(world, feetSliceAABB);
@@ -1132,6 +1163,9 @@ class BotcraftPhysics {
                 else {
                     player.supportingBlockPos = this.getSupportingBlockPos(world, feetSliceAABB.translate(-movement.x, 0.0, -movement.z));
                 }
+                if (!player.onGround && player.supportingBlockPos != null) {
+                    player.onGround = true;
+                }
                 // unnecessary due to it being a getter.
                 //  player->on_ground_without_supporting_block = !player->supporting_block_pos.has_value();
             }

package/dist/physics/engines/entityPhysics.js

@@ -533,7 +533,7 @@ class EntityPhysics {
         const gravityMultiplier = vel.y <= 0 && entity.state.slowFalling > 0 ? entity.worldSettings.slowFalling : 1;
         // Unsure how to handle this w/ other entities.
         // this is player-only.
-        if (entity.state.elytraFlying) {
+        if (entity.state.fallFlying) {
             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;
@@ -561,7 +561,7 @@ class EntityPhysics {
             vel.z *= 0.99;
             this.moveEntity(entity, vel.x, vel.y, vel.z, world);
             if (entity.state.onGround) {
-                entity.state.elytraFlying = false;
+                entity.state.fallFlying = false;
             }
         }
         else if (!entity.state.isInWater && !entity.state.isInLava) {
@@ -732,12 +732,12 @@ class EntityPhysics {
                 forward *= entity.worldSettings.usingItemSpeed;
                 entity.state.control.sprint = false;
             }
-            entity.state.elytraFlying =
-                entity.state.elytraFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
+            entity.state.fallFlying =
+                entity.state.fallFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
             // for now, only check if this is a player.
             if (entity.state instanceof states_1.PlayerState) {
                 if (entity.state.fireworkRocketDuration > 0) {
-                    if (!entity.state.elytraFlying) {
+                    if (!entity.state.fallFlying) {
                         entity.state.fireworkRocketDuration = 0;
                     }
                     else {

package/dist/physics/engines/optimizedPhysics.js

@@ -601,7 +601,7 @@ class EntityPhysics {
             vel.x *= inertia;
             vel.z *= inertia;
         }
-        else if (entity.state.elytraFlying) {
+        else if (entity.state.fallFlying) {
             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;
@@ -629,7 +629,7 @@ class EntityPhysics {
             vel.z *= 0.99;
             this.moveEntity(entity, world, vel.x, vel.y, vel.z);
             if (entity.state.onGround) {
-                entity.state.elytraFlying = false;
+                entity.state.fallFlying = false;
             }
         }
         else {
@@ -731,9 +731,9 @@ class EntityPhysics {
                 entity.state.control.sprint = false;
             }
         }
-        entity.state.elytraFlying = entity.state.elytraFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
+        entity.state.fallFlying = entity.state.fallFlying && entity.state.elytraEquipped && !entity.state.onGround && !entity.state.levitation;
         if (entity.state.fireworkRocketDuration > 0) {
-            if (!entity.state.elytraFlying) {
+            if (!entity.state.fallFlying) {
                 entity.state.fireworkRocketDuration = 0;
             }
             else {

package/dist/physics/settings/physicsSettings.js

@@ -9,7 +9,7 @@ class PhysicsWorldSettings {
         this.negligeableVelocity = 0.003; // actually 0.005 for 1.8; but seems fine
         this.soulsandSpeed = 0.4;
         this.honeyblockSpeed = 0.4;
-        this.honeyblockJumpSpeed = 0.4;
+        this.honeyblockJumpSpeed = 0.5;
         this.ladderMaxSpeed = 0.15;
         this.ladderClimbSpeed = 0.2;
         // public gravity: number = 0.08;

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

@@ -21,7 +21,7 @@ export declare class EntityState implements IEntityState {
     isInWater: boolean;
     isInLava: boolean;
     isInWeb: boolean;
-    elytraFlying: boolean;
+    fallFlying: boolean;
     elytraEquipped: boolean;
     isCollidedHorizontally: boolean;
     isCollidedVertically: boolean;
@@ -44,6 +44,11 @@ export declare class EntityState implements IEntityState {
     pose: PlayerPoses;
     fireworkRocketDuration: number;
     supportingBlockPos: Vec3 | null;
+    /**
+     * Deprecated compatibility alias for fallFlying.
+     */
+    get elytraFlying(): boolean;
+    set elytraFlying(value: boolean);
     constructor(ctx: IPhysics, height: number, halfWidth: number, pos: Vec3, vel: Vec3, onGround: boolean, yaw: number, pitch: number, control?: ControlStateHandler);
     static CREATE_FROM_BOT(ctx: IPhysics, bot: Bot): EntityState;
     static CREATE_FROM_ENTITY(ctx: IPhysics, entity: Entity): EntityState;

package/dist/physics/states/entityState.js

@@ -12,6 +12,15 @@ const poses_1 = require("./poses");
 const prismarine_nbt_1 = __importDefault(require("prismarine-nbt"));
 const emptyVec = new vec3_1.Vec3(0, 0, 0);
 class EntityState {
+    /**
+     * Deprecated compatibility alias for fallFlying.
+     */
+    get elytraFlying() {
+        return this.fallFlying;
+    }
+    set elytraFlying(value) {
+        this.fallFlying = value;
+    }
     // public effects: Effect[];
     // public statusEffectNames;
     constructor(ctx, height, halfWidth, pos, vel, onGround, yaw, pitch, control = playerControls_1.ControlStateHandler.DEFAULT()) {
@@ -30,7 +39,7 @@ class EntityState {
         this.isInWater = false;
         this.isInLava = false;
         this.isInWeb = false;
-        this.elytraFlying = false;
+        this.fallFlying = false;
         this.elytraEquipped = false;
         this.isCollidedHorizontally = false;
         this.isCollidedVertically = false;
@@ -83,7 +92,7 @@ class EntityState {
         return this;
     }
     updateFromEntity(entity, all = false) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (all) {
             // most mobs don't have this defined, so ignore it (only self does).
             this.vel = entity.velocity.clone();
@@ -92,13 +101,13 @@ class EntityState {
             this.isInWater = entity.isInWater;
             this.isInLava = entity.isInLava;
             this.isInWeb = entity.isInWeb;
-            this.elytraFlying = entity.elytraFlying;
+            this.fallFlying = (_b = (_a = entity.fallFlying) !== null && _a !== void 0 ? _a : entity.elytraFlying) !== null && _b !== void 0 ? _b : false;
             this.isCollidedHorizontally = entity.isCollidedHorizontally;
             this.isCollidedVertically = entity.isCollidedVertically;
             this.sneakCollision = false; //TODO
             this.attributes || (this.attributes = entity.attributes);
-            this.elytraEquipped = entity.equipment[4] && ((_a = entity.equipment[4]) === null || _a === void 0 ? void 0 : _a.name.includes("elytra"));
-            this.elytraFlying = this.elytraEquipped && this.elytraFlying;
+            this.elytraEquipped = entity.equipment[4] && ((_c = entity.equipment[4]) === null || _c === void 0 ? void 0 : _c.name.includes("elytra"));
+            this.fallFlying = this.elytraEquipped && this.fallFlying;
         }
         this.pos = entity.position.clone();
         //not sure what to do here, ngl.
@@ -124,7 +133,7 @@ class EntityState {
         const boots = entity.equipment[5];
         if (boots && boots.nbt) {
             const simplifiedNbt = prismarine_nbt_1.default.simplify(boots.nbt);
-            const enchantments = (_c = (_b = simplifiedNbt.Enchantments) !== null && _b !== void 0 ? _b : simplifiedNbt.ench) !== null && _c !== void 0 ? _c : [];
+            const enchantments = (_e = (_d = simplifiedNbt.Enchantments) !== null && _d !== void 0 ? _d : simplifiedNbt.ench) !== null && _e !== void 0 ? _e : [];
             this.depthStrider = this.ctx.getEnchantmentLevel(physicsUtils_1.CheapEnchantments.DEPTH_STRIDER, enchantments);
         }
         else {
@@ -134,7 +143,7 @@ class EntityState {
         return this;
     }
     updateFromRaw(other) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
         this.onGround = (_a = other.onGround) !== null && _a !== void 0 ? _a : this.onGround;
         this.onClimbable = (_b = other.onClimbable) !== null && _b !== void 0 ? _b : this.onClimbable;
         this.sneakCollision = (_c = other.sneakCollision) !== null && _c !== void 0 ? _c : this.sneakCollision;
@@ -152,8 +161,8 @@ class EntityState {
         this.isInWater = (_q = other.isInWater) !== null && _q !== void 0 ? _q : this.isInWater;
         this.isInLava = (_r = other.isInLava) !== null && _r !== void 0 ? _r : this.isInLava;
         this.isInWeb = (_s = other.isInWeb) !== null && _s !== void 0 ? _s : this.isInWeb;
-        this.elytraFlying = (_t = other.elytraFlying) !== null && _t !== void 0 ? _t : this.elytraFlying;
-        this.elytraEquipped = (_u = other.elytraEquipped) !== null && _u !== void 0 ? _u : this.elytraEquipped;
+        this.fallFlying = (_u = (_t = other.fallFlying) !== null && _t !== void 0 ? _t : other.elytraFlying) !== null && _u !== void 0 ? _u : this.fallFlying;
+        this.elytraEquipped = (_v = other.elytraEquipped) !== null && _v !== void 0 ? _v : this.elytraEquipped;
         return this;
     }
     applyToBot(bot) {
@@ -170,7 +179,8 @@ class EntityState {
         bot.entity.isInWater = this.isInWater;
         bot.entity.isInLava = this.isInLava;
         bot.entity.isInWeb = this.isInWeb;
-        bot.entity.elytraFlying = this.elytraFlying;
+        bot.entity.fallFlying = this.fallFlying;
+        bot.entity.elytraFlying = this.fallFlying;
         bot.entity.elytraEquipped = this.elytraEquipped;
         bot.entity.isCollidedHorizontally = this.isCollidedHorizontally;
         bot.entity.isCollidedVertically = this.isCollidedVertically;
@@ -202,7 +212,7 @@ class EntityState {
         other.isInWater = this.isInWater;
         other.isInLava = this.isInLava;
         other.isInWeb = this.isInWeb;
-        other.elytraFlying = this.elytraFlying;
+        other.fallFlying = this.fallFlying;
         other.elytraEquipped = this.elytraEquipped;
         other.fireworkRocketDuration = this.fireworkRocketDuration;
         other.jumpTicks = this.jumpTicks;
@@ -234,7 +244,7 @@ class EntityState {
         this.isInWater = other.isInWater;
         this.isInLava = other.isInLava;
         this.isInWeb = other.isInWeb;
-        this.elytraFlying = other.elytraFlying;
+        this.fallFlying = other.fallFlying;
         this.elytraEquipped = other.elytraEquipped;
         this.fireworkRocketDuration = other.fireworkRocketDuration;
         this.jumpTicks = other.jumpTicks;

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

@@ -27,6 +27,7 @@ export interface IEntityState {
     isInWater: boolean;
     isInLava: boolean;
     isInWeb: boolean;
+    fallFlying: boolean;
     elytraFlying: boolean;
     elytraEquipped: boolean;
     fireworkRocketDuration: number;

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

@@ -33,13 +33,13 @@ export declare class PlayerState implements IEntityState {
     pos: Vec3;
     vel: Vec3;
     onGround: boolean;
+    lastOnGround: boolean;
     onClimbable: boolean;
     isInWater: boolean;
     isUnderWater: boolean;
     isInLava: boolean;
     isUnderLava: boolean;
     isInWeb: boolean;
-    elytraFlying: boolean;
     elytraEquipped: boolean;
     fireworkRocketDuration: number;
     isCollidedHorizontally: boolean;
@@ -103,6 +103,11 @@ export declare class PlayerState implements IEntityState {
      * TODO: proper impl.
      */
     fallFlying: boolean;
+    /**
+     * Deprecated compatibility alias for fallFlying.
+     */
+    get elytraFlying(): boolean;
+    set elytraFlying(value: boolean);
     /**
      * TODO: proper impl.
      */