@nxg-org/mineflayer-physics-util 1.7.0 → 1.7.2

package/dist/index.d.ts

@@ -8,7 +8,7 @@ declare module "mineflayer" {
 }
 export default function loader(bot: Bot): void;
 export declare function initSetup(data: IndexedData): void;
-export { EPhysicsCtx, PhysicsSettings as PhysicsSettings } from "./physics/settings";
+export { EPhysicsCtx, PhysicsWorldSettings } from "./physics/settings";
 export { BaseSimulator } from "./simulators";
 export { EntityPhysics } from "./physics/engines";
 export { EntityState } from "./physics/states";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlStateHandler = exports.EntityState = exports.EntityPhysics = exports.BaseSimulator = exports.PhysicsSettings = exports.EPhysicsCtx = exports.initSetup = void 0;
+exports.ControlStateHandler = exports.EntityState = exports.EntityPhysics = exports.BaseSimulator = exports.PhysicsWorldSettings = exports.EPhysicsCtx = exports.initSetup = void 0;
 const settings_1 = require("./physics/settings");
 const wrapper_1 = require("./wrapper");
 function loader(bot) {
@@ -16,7 +16,7 @@ function initSetup(data) {
 exports.initSetup = initSetup;
 var settings_2 = require("./physics/settings");
 Object.defineProperty(exports, "EPhysicsCtx", { enumerable: true, get: function () { return settings_2.EPhysicsCtx; } });
-Object.defineProperty(exports, "PhysicsSettings", { enumerable: true, get: function () { return settings_2.PhysicsSettings; } });
+Object.defineProperty(exports, "PhysicsWorldSettings", { enumerable: true, get: function () { return settings_2.PhysicsWorldSettings; } });
 var simulators_1 = require("./simulators");
 Object.defineProperty(exports, "BaseSimulator", { enumerable: true, get: function () { return simulators_1.BaseSimulator; } });
 var engines_1 = require("./physics/engines");

package/dist/physics/engines/entityPhysics.js

@@ -310,12 +310,12 @@ class EntityPhysics {
                     if (block) {
                         if (entity.collisionBehavior.blockEffects && this.supportFeature("velocityBlocksOnCollision")) {
                             if (block.type === this.soulsandId) {
-                                vel.x *= entity.settings.soulsandSpeed;
-                                vel.z *= entity.settings.soulsandSpeed;
+                                vel.x *= entity.worldSettings.soulsandSpeed;
+                                vel.z *= entity.worldSettings.soulsandSpeed;
                             }
                             else if (block.type === this.honeyblockId) {
-                                vel.x *= entity.settings.honeyblockSpeed;
-                                vel.z *= entity.settings.honeyblockSpeed;
+                                vel.x *= entity.worldSettings.honeyblockSpeed;
+                                vel.z *= entity.worldSettings.honeyblockSpeed;
                             }
                         }
                         if (block.type === this.webId) {
@@ -325,7 +325,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 */ ? entity.settings.bubbleColumnSurfaceDrag : entity.settings.bubbleColumnDrag;
+                            const bubbleDrag = aboveBlock && aboveBlock.type === 0 /* air */ ? entity.worldSettings.bubbleColumnSurfaceDrag : entity.worldSettings.bubbleColumnDrag;
                             if (down) {
                                 vel.y = Math.max(bubbleDrag.maxDown, vel.y - bubbleDrag.down);
                             }
@@ -341,12 +341,12 @@ class EntityPhysics {
             const blockBelow = world.getBlock(entity.position.floored().offset(0, -0.5, 0));
             if (blockBelow) {
                 if (blockBelow.type === this.soulsandId) {
-                    vel.x *= entity.settings.soulsandSpeed;
-                    vel.z *= entity.settings.soulsandSpeed;
+                    vel.x *= entity.worldSettings.soulsandSpeed;
+                    vel.z *= entity.worldSettings.soulsandSpeed;
                 }
                 else if (blockBelow.type === this.honeyblockId) {
-                    vel.x *= entity.settings.honeyblockSpeed;
-                    vel.z *= entity.settings.honeyblockSpeed;
+                    vel.x *= entity.worldSettings.honeyblockSpeed;
+                    vel.z *= entity.worldSettings.honeyblockSpeed;
                 }
             }
         }
@@ -517,7 +517,7 @@ class EntityPhysics {
         }
         const vel = entity.velocity;
         const pos = entity.position;
-        const gravityMultiplier = vel.y <= 0 && entity.state.slowFalling > 0 ? entity.settings.slowFalling : 1;
+        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) {
@@ -564,24 +564,24 @@ class EntityPhysics {
                 else {
                     // Create an attribute if the player does not have it
                     //TODO: Generalize to all entities.
-                    playerSpeedAttribute = attributes.createAttributeValue(entity.settings.playerSpeed);
+                    playerSpeedAttribute = attributes.createAttributeValue(entity.worldSettings.playerSpeed);
                 }
                 // Client-side sprinting (don't rely on server-side sprinting)
                 // setSprinting in LivingEntity.java
                 //TODO: Generalize to all entities.
-                playerSpeedAttribute = attributes.deleteAttributeModifier(playerSpeedAttribute, entity.settings.sprintingUUID); // always delete sprinting (if it exists)
+                playerSpeedAttribute = attributes.deleteAttributeModifier(playerSpeedAttribute, entity.worldSettings.sprintingUUID); // always delete sprinting (if it exists)
                 if (entity.state.control.sprint) {
-                    if (!attributes.checkAttributeModifier(playerSpeedAttribute, entity.settings.sprintingUUID)) {
+                    if (!attributes.checkAttributeModifier(playerSpeedAttribute, entity.worldSettings.sprintingUUID)) {
                         playerSpeedAttribute = attributes.addAttributeModifier(playerSpeedAttribute, {
-                            uuid: entity.settings.sprintingUUID,
-                            amount: entity.settings.sprintSpeed,
+                            uuid: entity.worldSettings.sprintingUUID,
+                            amount: entity.worldSettings.sprintSpeed,
                             operation: 2,
                         });
                     }
                 }
                 // Calculate what the speed is (0.1 if no modification)
                 const attributeSpeed = attributes.getAttributeValue(playerSpeedAttribute);
-                dragOrFriction = (this.blockSlipperiness[blockUnder.type] || entity.settings.defaultSlipperiness) * 0.91;
+                dragOrFriction = (this.blockSlipperiness[blockUnder.type] || entity.worldSettings.defaultSlipperiness) * 0.91;
                 acceleration = attributeSpeed * (0.1627714 / (dragOrFriction * dragOrFriction * dragOrFriction));
                 if (acceleration < 0)
                     acceleration = 0; // acceleration should not be negative
@@ -590,15 +590,15 @@ class EntityPhysics {
             this.applyHeading(entity, strafe, forward, acceleration);
             // console.log('vel 1!', vel)
             if (entity.collisionBehavior.blockEffects && this.isOnLadder(pos, world)) {
-                vel.x = math.clamp(-entity.settings.ladderMaxSpeed, vel.x, entity.settings.ladderMaxSpeed);
-                vel.z = math.clamp(-entity.settings.ladderMaxSpeed, vel.z, entity.settings.ladderMaxSpeed);
-                vel.y = Math.max(vel.y, entity.state.control.sneak ? 0 : -entity.settings.ladderMaxSpeed);
+                vel.x = math.clamp(-entity.worldSettings.ladderMaxSpeed, vel.x, entity.worldSettings.ladderMaxSpeed);
+                vel.z = math.clamp(-entity.worldSettings.ladderMaxSpeed, vel.z, entity.worldSettings.ladderMaxSpeed);
+                vel.y = Math.max(vel.y, entity.state.control.sneak ? 0 : -entity.worldSettings.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 = entity.settings.ladderClimbSpeed; // climb ladder
+                vel.y = entity.worldSettings.ladderClimbSpeed; // climb ladder
             }
             // Not adding an additional function call. No point.
             if (entity.gravityThenDrag) {
@@ -652,7 +652,7 @@ class EntityPhysics {
             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 = entity.settings.outOfLiquidImpulse; // jump out of liquid
+                vel.y = entity.worldSettings.outOfLiquidImpulse; // jump out of liquid
             }
         }
     }
@@ -670,11 +670,11 @@ class EntityPhysics {
         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) < entity.settings.negligeableVelocity)
+        if (Math.abs(vel.x) < entity.worldSettings.negligeableVelocity)
             vel.x = 0;
-        if (Math.abs(vel.y) < entity.settings.negligeableVelocity)
+        if (Math.abs(vel.y) < entity.worldSettings.negligeableVelocity)
             vel.y = 0;
-        if (Math.abs(vel.z) < entity.settings.negligeableVelocity)
+        if (Math.abs(vel.z) < entity.worldSettings.negligeableVelocity)
             vel.z = 0;
         let strafe = 0;
         let forward = 0;
@@ -688,7 +688,7 @@ class EntityPhysics {
                 }
                 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 ? entity.settings.honeyblockJumpSpeed : 1);
+                    vel.y = Math.fround(0.42) * (blockBelow && blockBelow.type === this.honeyblockId ? entity.worldSettings.honeyblockJumpSpeed : 1);
                     if (entity.state.jumpBoost > 0) {
                         vel.y += 0.1 * entity.state.jumpBoost;
                     }
@@ -697,7 +697,7 @@ class EntityPhysics {
                         vel.x -= Math.sin(yaw) * 0.2;
                         vel.z += Math.cos(yaw) * 0.2;
                     }
-                    entity.state.jumpTicks = entity.settings.autojumpCooldown;
+                    entity.state.jumpTicks = entity.worldSettings.autojumpCooldown;
                 }
             }
             else {
@@ -707,13 +707,13 @@ class EntityPhysics {
             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 *= entity.settings.sneakSpeed;
-                forward *= entity.settings.sneakSpeed;
+                strafe *= entity.worldSettings.sneakSpeed;
+                forward *= entity.worldSettings.sneakSpeed;
                 entity.state.control.sprint = false;
             }
             if (entity.state.isUsingItem) {
-                strafe *= entity.settings.usingItemSpeed;
-                forward *= entity.settings.usingItemSpeed;
+                strafe *= entity.worldSettings.usingItemSpeed;
+                forward *= entity.worldSettings.usingItemSpeed;
                 entity.state.control.sprint = false;
             }
             entity.state.elytraFlying =

package/dist/physics/engines/optimizedPhysics.js

@@ -313,12 +313,12 @@ class EntityPhysics {
                     if (block) {
                         if (entity.collisionBehavior.blockEffects && this.supportFeature("velocityBlocksOnCollision")) {
                             if (block.type === this.soulsandId) {
-                                vel.x *= entity.settings.soulsandSpeed;
-                                vel.z *= entity.settings.soulsandSpeed;
+                                vel.x *= entity.worldSettings.soulsandSpeed;
+                                vel.z *= entity.worldSettings.soulsandSpeed;
                             }
                             else if (block.type === this.honeyblockId) {
-                                vel.x *= entity.settings.honeyblockSpeed;
-                                vel.z *= entity.settings.honeyblockSpeed;
+                                vel.x *= entity.worldSettings.honeyblockSpeed;
+                                vel.z *= entity.worldSettings.honeyblockSpeed;
                             }
                         }
                         if (block.type === this.webId) {
@@ -329,8 +329,8 @@ class EntityPhysics {
                             const down = !block.metadata;
                             const aboveBlock = world.getBlock(cursor.offset(0, 1, 0));
                             const bubbleDrag = aboveBlock && aboveBlock.type === 0 /* air */
-                                ? entity.settings.bubbleColumnSurfaceDrag
-                                : entity.settings.bubbleColumnDrag;
+                                ? entity.worldSettings.bubbleColumnSurfaceDrag
+                                : entity.worldSettings.bubbleColumnDrag;
                             if (down) {
                                 vel.y = Math.max(bubbleDrag.maxDown, vel.y - bubbleDrag.down);
                             }
@@ -346,12 +346,12 @@ class EntityPhysics {
             const blockBelow = world.getBlock(entity.position.floored().offset(0, -0.5, 0));
             if (blockBelow) {
                 if (blockBelow.type === this.soulsandId) {
-                    vel.x *= entity.settings.soulsandSpeed;
-                    vel.z *= entity.settings.soulsandSpeed;
+                    vel.x *= entity.worldSettings.soulsandSpeed;
+                    vel.z *= entity.worldSettings.soulsandSpeed;
                 }
                 else if (blockBelow.type === this.honeyblockId) {
-                    vel.x *= entity.settings.honeyblockSpeed;
-                    vel.z *= entity.settings.honeyblockSpeed;
+                    vel.x *= entity.worldSettings.honeyblockSpeed;
+                    vel.z *= entity.worldSettings.honeyblockSpeed;
                 }
             }
         }
@@ -522,7 +522,7 @@ class EntityPhysics {
         }
         const vel = entity.velocity;
         const pos = entity.position;
-        const gravityMultiplier = vel.y <= 0 && entity.state.slowFalling > 0 ? entity.settings.slowFalling : 1;
+        const gravityMultiplier = vel.y <= 0 && entity.state.slowFalling > 0 ? entity.worldSettings.slowFalling : 1;
         // Unsure how to handle this w/ other entities.
         if (!entity.state.isInWater && !entity.state.isInLava) {
             let acceleration = entity.airborneAccel;
@@ -537,39 +537,39 @@ class EntityPhysics {
                 else {
                     // Create an attribute if the player does not have it
                     //TODO: Generalize to all entities.
-                    playerSpeedAttribute = attributes.createAttributeValue(entity.settings.playerSpeed);
+                    playerSpeedAttribute = attributes.createAttributeValue(entity.worldSettings.playerSpeed);
                 }
                 // Client-side sprinting (don't rely on server-side sprinting)
                 // setSprinting in LivingEntity.java
                 //TODO: Generalize to all entities.
-                playerSpeedAttribute = attributes.deleteAttributeModifier(playerSpeedAttribute, entity.settings.sprintingUUID); // always delete sprinting (if it exists)
+                playerSpeedAttribute = attributes.deleteAttributeModifier(playerSpeedAttribute, entity.worldSettings.sprintingUUID); // always delete sprinting (if it exists)
                 if (entity.state.control.sprint) {
-                    if (!attributes.checkAttributeModifier(playerSpeedAttribute, entity.settings.sprintingUUID)) {
+                    if (!attributes.checkAttributeModifier(playerSpeedAttribute, entity.worldSettings.sprintingUUID)) {
                         playerSpeedAttribute = attributes.addAttributeModifier(playerSpeedAttribute, {
-                            uuid: entity.settings.sprintingUUID,
-                            amount: entity.settings.sprintSpeed,
+                            uuid: entity.worldSettings.sprintingUUID,
+                            amount: entity.worldSettings.sprintSpeed,
                             operation: 2,
                         });
                     }
                 }
                 // Calculate what the speed is (0.1 if no modification)
                 const attributeSpeed = attributes.getAttributeValue(playerSpeedAttribute);
-                inertia = (this.blockSlipperiness[blockUnder.type] || entity.settings.defaultSlipperiness) * 0.91;
+                inertia = (this.blockSlipperiness[blockUnder.type] || entity.worldSettings.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(-entity.settings.ladderMaxSpeed, vel.x, entity.settings.ladderMaxSpeed);
-                vel.z = math.clamp(-entity.settings.ladderMaxSpeed, vel.z, entity.settings.ladderMaxSpeed);
-                vel.y = Math.max(vel.y, entity.state.control.sneak ? 0 : -entity.settings.ladderMaxSpeed);
+                vel.x = math.clamp(-entity.worldSettings.ladderMaxSpeed, vel.x, entity.worldSettings.ladderMaxSpeed);
+                vel.z = math.clamp(-entity.worldSettings.ladderMaxSpeed, vel.z, entity.worldSettings.ladderMaxSpeed);
+                vel.y = Math.max(vel.y, entity.state.control.sneak ? 0 : -entity.worldSettings.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 = entity.settings.ladderClimbSpeed; // climb ladder
+                vel.y = entity.worldSettings.ladderClimbSpeed; // climb ladder
             }
             // Not adding an additional function call. No point.
             if (entity.gravityThenDrag) {
@@ -654,7 +654,7 @@ class EntityPhysics {
             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 = entity.settings.outOfLiquidImpulse; // jump out of liquid
+                vel.y = entity.worldSettings.outOfLiquidImpulse; // jump out of liquid
             }
         }
     }
@@ -671,11 +671,11 @@ class EntityPhysics {
         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) < entity.settings.negligeableVelocity)
+        if (Math.abs(vel.x) < entity.worldSettings.negligeableVelocity)
             vel.x = 0;
-        if (Math.abs(vel.y) < entity.settings.negligeableVelocity)
+        if (Math.abs(vel.y) < entity.worldSettings.negligeableVelocity)
             vel.y = 0;
-        if (Math.abs(vel.z) < entity.settings.negligeableVelocity)
+        if (Math.abs(vel.z) < entity.worldSettings.negligeableVelocity)
             vel.z = 0;
         let strafe = 0;
         let forward = 0;
@@ -690,7 +690,7 @@ class EntityPhysics {
                 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 ? entity.settings.honeyblockJumpSpeed : 1);
+                        Math.fround(0.42) * (blockBelow && blockBelow.type === this.honeyblockId ? entity.worldSettings.honeyblockJumpSpeed : 1);
                     if (entity.state.jumpBoost > 0) {
                         vel.y += 0.1 * entity.state.jumpBoost;
                     }
@@ -699,7 +699,7 @@ class EntityPhysics {
                         vel.x -= Math.sin(yaw) * 0.2;
                         vel.z += Math.cos(yaw) * 0.2;
                     }
-                    entity.state.jumpTicks = entity.settings.autojumpCooldown;
+                    entity.state.jumpTicks = entity.worldSettings.autojumpCooldown;
                 }
             }
             else {
@@ -711,13 +711,13 @@ class EntityPhysics {
             forward =
                 (entity.state.control.forward - entity.state.control.back) * 0.98;
             if (entity.state.control.sneak) {
-                strafe *= entity.settings.sneakSpeed;
-                forward *= entity.settings.sneakSpeed;
+                strafe *= entity.worldSettings.sneakSpeed;
+                forward *= entity.worldSettings.sneakSpeed;
                 entity.state.control.sprint = false;
             }
             if (entity.state.isUsingItem) {
-                strafe *= entity.settings.usingItemSpeed;
-                forward *= entity.settings.usingItemSpeed;
+                strafe *= entity.worldSettings.usingItemSpeed;
+                forward *= entity.worldSettings.usingItemSpeed;
                 entity.state.control.sprint = false;
             }
         }

package/dist/physics/settings/entityPhysicsCtx.d.ts

@@ -6,7 +6,7 @@ import { Vec3 } from "vec3";
 import { IPhysics } from "../engines/IPhysics";
 import { EntityState } from "../states/entityState";
 import { PlayerPoses } from "../states/poses";
-import { PhysicsSettings } from "./physicsSettings";
+import { PhysicsWorldSettings } from "./physicsSettings";
 export declare const emptyVec: Vec3;
 type PlayerPoseContext = {
     [key in PlayerPoses]: {
@@ -20,7 +20,7 @@ type CollisionContext = {
 };
 export declare class EPhysicsCtx {
     readonly ctx: IPhysics;
-    readonly settings: PhysicsSettings;
+    readonly worldSettings: PhysicsWorldSettings;
     pose: PlayerPoses;
     readonly state: EntityState;
     readonly entityType: md.Entity;
@@ -35,26 +35,26 @@ export declare class EPhysicsCtx {
     static readonly playerPoseContext: PlayerPoseContext;
     readonly position: Vec3;
     readonly velocity: Vec3;
-    readonly stepHeight: number;
-    readonly gravity: number;
-    readonly waterGravity: number;
-    readonly lavaGravity: number;
-    readonly airdrag: number;
-    readonly airborneInertia: number;
-    readonly airborneAccel: number;
-    readonly waterInertia: number;
-    readonly lavaInertia: number;
-    readonly liquidAccel: number;
-    readonly gravityThenDrag: boolean;
-    readonly useControls: boolean;
+    stepHeight: number;
+    gravity: number;
+    waterGravity: number;
+    lavaGravity: number;
+    airdrag: number;
+    airborneInertia: number;
+    airborneAccel: number;
+    waterInertia: number;
+    lavaInertia: number;
+    liquidAccel: number;
+    gravityThenDrag: boolean;
+    useControls: boolean;
     doSolidCollisions: boolean;
     doLiquidCollisions: boolean;
     readonly collisionBehavior: CollisionContext;
-    constructor(ctx: IPhysics, settings: PhysicsSettings, pose: PlayerPoses, state: EntityState, entityType?: md.Entity);
-    static FROM_BOT(ctx: IPhysics, bot: Bot, settings?: PhysicsSettings): EPhysicsCtx;
-    static FROM_ENTITY(ctx: IPhysics, entity: Entity, settings?: PhysicsSettings): EPhysicsCtx;
-    static FROM_ENTITY_TYPE(ctx: IPhysics, entityType: md.Entity, options?: Partial<Entity>, settings?: PhysicsSettings): EPhysicsCtx;
-    static FROM_ENTITY_STATE(ctx: IPhysics, entityState: EntityState, entityType?: md.Entity, settings?: PhysicsSettings): EPhysicsCtx;
+    constructor(ctx: IPhysics, worldSettings: PhysicsWorldSettings, pose: PlayerPoses, state: EntityState, entityType?: md.Entity);
+    static FROM_BOT(ctx: IPhysics, bot: Bot, settings?: PhysicsWorldSettings): EPhysicsCtx;
+    static FROM_ENTITY(ctx: IPhysics, entity: Entity, settings?: PhysicsWorldSettings): EPhysicsCtx;
+    static FROM_ENTITY_TYPE(ctx: IPhysics, entityType: md.Entity, options?: Partial<Entity>, settings?: PhysicsWorldSettings): EPhysicsCtx;
+    static FROM_ENTITY_STATE(ctx: IPhysics, entityState: EntityState, entityType?: md.Entity, settings?: PhysicsWorldSettings): EPhysicsCtx;
     clone(): EPhysicsCtx;
     get height(): number;
     get width(): number;

package/dist/physics/settings/entityPhysicsCtx.js

@@ -24,15 +24,15 @@ function load(data) {
 }
 exports.emptyVec = new vec3_1.Vec3(0, 0, 0);
 class EPhysicsCtx {
-    constructor(ctx, settings, pose, state, entityType = physicsUtils_1.DefaultPlayer) {
+    constructor(ctx, worldSettings, pose, state, entityType = physicsUtils_1.DefaultPlayer) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         this.ctx = ctx;
-        this.settings = settings;
+        this.worldSettings = worldSettings;
         this.pose = pose;
         this.state = state;
         this.entityType = entityType;
         this.stepHeight = 0;
-        this.gravity = 0.0;
+        this.gravity = 0.08;
         this.airdrag = Math.fround(1 - 0.0);
         this.airborneInertia = 0.91;
         this.airborneAccel = 0.02;
@@ -145,25 +145,25 @@ class EPhysicsCtx {
         }
     }
     static FROM_BOT(ctx, bot, settings) {
-        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsSettings(bot.registry));
+        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsWorldSettings(bot.registry));
         return new EPhysicsCtx(ctx, settings, getPose(bot.entity), entityState_1.EntityState.CREATE_FROM_BOT(ctx, bot));
     }
     static FROM_ENTITY(ctx, entity, settings) {
-        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsSettings(ctx.data));
+        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsWorldSettings(ctx.data));
         return new EPhysicsCtx(ctx, settings, getPose(entity), entityState_1.EntityState.CREATE_FROM_ENTITY(ctx, entity), EPhysicsCtx.entityData[entity.name]);
     }
     static FROM_ENTITY_TYPE(ctx, entityType, options = {}, settings) {
         // unneeded for most entities, use a default.
-        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsSettings(ctx.data));
+        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsWorldSettings(ctx.data));
         const newE = (0, physicsUtils_1.applyMdToNewEntity)(EPhysicsCtx, entityType, options);
         return new EPhysicsCtx(ctx, settings, poses_1.PlayerPoses.STANDING, entityState_1.EntityState.CREATE_FROM_ENTITY(ctx, newE), entityType);
     }
     static FROM_ENTITY_STATE(ctx, entityState, entityType, settings) {
-        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsSettings(ctx.data));
+        settings !== null && settings !== void 0 ? settings : (settings = new physicsSettings_1.PhysicsWorldSettings(ctx.data));
         return new EPhysicsCtx(ctx, settings, entityState.pose, entityState, entityType);
     }
     clone() {
-        return new EPhysicsCtx(this.ctx, this.settings, this.state.pose, this.state.clone(), this.entityType);
+        return new EPhysicsCtx(this.ctx, this.worldSettings, this.state.pose, this.state.clone(), this.entityType);
     }
     get height() {
         var _a, _b;

package/dist/physics/settings/physicsSettings.d.ts

@@ -5,12 +5,10 @@ type BubbleColumnInfo = {
     up: number;
     maxUp: number;
 };
-export declare class PhysicsSettings {
+export declare class PhysicsWorldSettings {
     mcData: md.IndexedData;
     entityData: md.IndexedData["entitiesByName"];
     mobData: md.IndexedData["mobs"];
-    yawSpeed: number;
-    pitchSpeed: number;
     playerSpeed: number;
     stepHeight: number;
     negligeableVelocity: number;
@@ -19,9 +17,6 @@ export declare class PhysicsSettings {
     honeyblockJumpSpeed: number;
     ladderMaxSpeed: number;
     ladderClimbSpeed: number;
-    waterInertia: number;
-    lavaInertia: number;
-    liquidAcceleration: number;
     defaultSlipperiness: number;
     outOfLiquidImpulse: number;
     autojumpCooldown: number;
@@ -30,8 +25,6 @@ export declare class PhysicsSettings {
     slowFalling: number;
     sprintingUUID: string;
     jumpHeight: number;
-    airborneInertia: number;
-    airborneAcceleration: number;
     sprintSpeed: number;
     sneakSpeed: number;
     usingItemSpeed: number;

package/dist/physics/settings/physicsSettings.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhysicsSettings = void 0;
-class PhysicsSettings {
+exports.PhysicsWorldSettings = void 0;
+class PhysicsWorldSettings {
     constructor(mcData) {
-        this.yawSpeed = 3.0;
-        this.pitchSpeed = 3.0;
+        // public yawSpeed: number = 3.0;
+        // public pitchSpeed: number = 3.0;
         this.playerSpeed = 0.1;
         this.stepHeight = 0.6; // how much height can the bot step on without jump
         this.negligeableVelocity = 0.003; // actually 0.005 for 1.8; but seems fine
@@ -13,9 +13,10 @@ class PhysicsSettings {
         this.honeyblockJumpSpeed = 0.4;
         this.ladderMaxSpeed = 0.15;
         this.ladderClimbSpeed = 0.2;
-        this.waterInertia = 0.8;
-        this.lavaInertia = 0.5;
-        this.liquidAcceleration = 0.02;
+        // public gravity: number = 0.08;
+        // public waterInertia: number = 0.8;
+        // public lavaInertia: number = 0.5;
+        // public liquidAcceleration: number = 0.02;
         this.defaultSlipperiness = 0.6;
         this.outOfLiquidImpulse = 0.3;
         this.autojumpCooldown = 10; // ticks (0.5s)
@@ -34,8 +35,6 @@ class PhysicsSettings {
         this.slowFalling = 0.125;
         this.sprintingUUID = "662a6b8d-da3e-4c1c-8813-96ea6097278d"; // SPEED_MODIFIER_SPRINTING_UUID is from LivingEntity.java
         this.jumpHeight = Math.fround(0.42);
-        this.airborneInertia = 0.99;
-        this.airborneAcceleration = 0.06;
         this.sprintSpeed = Math.fround(0.3);
         this.sneakSpeed = 0.3;
         this.usingItemSpeed = 0.2;
@@ -44,4 +43,4 @@ class PhysicsSettings {
         this.mobData = mcData["mobs"];
     }
 }
-exports.PhysicsSettings = PhysicsSettings;
+exports.PhysicsWorldSettings = PhysicsWorldSettings;

package/package.json

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

package/tests/fakeWorld.ts

@@ -2,7 +2,7 @@ import type { Entity } from "prismarine-entity";
 import type { Effect } from "mineflayer";
 import { EntityPhysics } from "../src/physics/engines";
 import { EntityState } from "../src/physics/states";
-import { EPhysicsCtx, PhysicsSettings } from "../src/physics/settings";
+import { EPhysicsCtx, PhysicsWorldSettings } from "../src/physics/settings";
 import { applyMdToNewEntity } from "../src/util/physicsUtils";
 import { ControlStateHandler } from "../src/physics/player";
 import { Vec3 } from "vec3";
@@ -69,8 +69,23 @@ const playerCtx = EPhysicsCtx.FROM_ENTITY_STATE(physics, playerState, playerType
 
 // set control state.
 playerState.control = ControlStateHandler.DEFAULT(); // specific to players and mobs, specify control scheme to apply.
-playerState.control.forward = true;
 
+const orgGravity = playerCtx.worldSettings.gravity;
+// modify gravity to be 0.
+playerCtx.worldSettings.gravity = 0;
+
+for (let i = 0; i < 20; i++) {
+    physics.simulate(playerCtx, fakeWorld).applyToBot(fakePlayer as any); // (applyToBot since fakePlayer is supposed to be a bot)
+    // console.log(fakePlayer.entity.position, fakePlayer.entity.velocity);
+}
+
+expect(fakePlayer.entity.position).toEqual(new Vec3(0, groundLevel + 20, 0)); // it works.
+
+// now, reset gravity.
+playerCtx.worldSettings.gravity = orgGravity;
+
+// set control for forward movement test.
+playerState.control.forward = true;
 
 // simulate until on ground.
 while (!playerCtx.state.onGround) {
@@ -97,4 +112,5 @@ if (playerState.control.forward) {
 }
 
 
+
 console.log(fakePlayer.entity.position); //manual run.