@nxg-org/mineflayer-physics-util 1.5.11 → 1.6.1

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 } from "./physics/settings";
+export { EPhysicsCtx, PhysicsSettings as PhysicsSettings } from "./physics/settings";
 export { BaseSimulator } from "./simulators";
 export { EntityPhysics } from "./physics/engines";
 export { EntityState } from "./physics/states";

package/dist/index.js

@@ -12,7 +12,6 @@ function loader(bot) {
 exports.default = loader;
 function initSetup(data) {
     settings_1.EPhysicsCtx.loadData(data);
-    settings_1.PhysicsSettings.loadData(data);
 }
 exports.initSetup = initSetup;
 var settings_2 = require("./physics/settings");

package/dist/physics/info/entity_physics.json

@@ -18,7 +18,8 @@
             }
         },
         "player": {
-            "stepHeight": 0.6
+            "stepHeight": 0.6,
+            "airborneInertia": 0.91
         }
     },
     "projectiles": {

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

@@ -6,6 +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";
 export declare const emptyVec: Vec3;
 type PlayerPoseContext = {
     [key in PlayerPoses]: {
@@ -27,6 +28,7 @@ export declare class EPhysicsCtx {
     static mcData: md.IndexedData;
     static entityData: md.IndexedData["entitiesByName"];
     static mobData: md.IndexedData["mobs"];
+    static globalSettings: typeof PhysicsSettings;
     /**
      * From minecraft's Player.java file.
      */
@@ -68,5 +70,6 @@ export declare class EPhysicsCtx {
         y: number;
         z: number;
     }): AABB;
+    updateFromBot(bot: Bot): void;
 }
 export {};

package/dist/physics/settings/entityPhysicsCtx.js

@@ -11,6 +11,7 @@ const physicsUtils_1 = require("../../util/physicsUtils");
 const entityState_1 = require("../states/entityState");
 const poses_1 = require("../states/poses");
 const entity_physics_json_1 = __importDefault(require("../info/entity_physics.json"));
+const physicsSettings_1 = require("./physicsSettings");
 function getPose(entity) {
     const pose = entity.metadata.find((e) => (e === null || e === void 0 ? void 0 : e.type) === 18);
     return pose ? pose.value : poses_1.PlayerPoses.STANDING;
@@ -47,6 +48,7 @@ class EPhysicsCtx {
         };
         this.position = state.pos;
         this.velocity = state.vel;
+        // TODO cleanup all of this code.
         if (entityType.type === "player" || !!EPhysicsCtx.mobData[entityType.id]) {
             // @ts-expect-error
             const additional = entity_physics_json_1.default.living_entities[entityType.type];
@@ -187,9 +189,20 @@ class EPhysicsCtx {
         const halfWidth = this.entityType.width ? this.entityType.width / 2 : 0;
         return new mineflayer_util_plugin_1.AABB(position.x - halfWidth, position.y, position.z - halfWidth, position.x + halfWidth, position.y + ((_a = this.entityType.height) !== null && _a !== void 0 ? _a : 0), position.z + halfWidth);
     }
+    updateFromBot(bot) {
+        this.state.updateFromBot(bot);
+        this.pose = getPose(bot.entity);
+        switch (bot.game.gameMode) {
+            case "survival":
+            case "creative":
+            case "adventure":
+            case "spectator":
+        }
+    }
 }
 exports.EPhysicsCtx = EPhysicsCtx;
 EPhysicsCtx.loadData = load;
+EPhysicsCtx.globalSettings = physicsSettings_1.PhysicsSettings;
 /**
  * From minecraft's Player.java file.
  */

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

@@ -5,6 +5,41 @@ type BubbleColumnInfo = {
     up: number;
     maxUp: number;
 };
+export declare class OPhysicsSettings {
+    mcData: md.IndexedData;
+    entityData: md.IndexedData["entitiesByName"];
+    mobData: md.IndexedData["mobs"];
+    yawSpeed: number;
+    pitchSpeed: number;
+    playerSpeed: number;
+    stepHeight: number;
+    negligeableVelocity: number;
+    soulsandSpeed: number;
+    honeyblockSpeed: number;
+    honeyblockJumpSpeed: number;
+    ladderMaxSpeed: number;
+    ladderClimbSpeed: number;
+    waterInertia: number;
+    lavaInertia: number;
+    liquidAcceleration: number;
+    defaultSlipperiness: number;
+    outOfLiquidImpulse: number;
+    autojumpCooldown: number;
+    bubbleColumnSurfaceDrag: BubbleColumnInfo;
+    bubbleColumnDrag: BubbleColumnInfo;
+    slowFalling: number;
+    sprintingUUID: string;
+    jumpHeight: number;
+    airborneInertia: number;
+    airborneAcceleration: number;
+    sprintSpeed: number;
+    sneakSpeed: number;
+    usingItemSpeed: number;
+    constructor(mcData: md.IndexedData);
+}
+/**
+ * @deprecated Use PlayerPhysicsSettings instead
+ */
 export declare class PhysicsSettings {
     static loadData: (data: md.IndexedData) => void;
     static mcData: md.IndexedData;

package/dist/physics/settings/physicsSettings.js

@@ -1,11 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhysicsSettings = void 0;
+exports.PhysicsSettings = exports.OPhysicsSettings = void 0;
+class OPhysicsSettings {
+    constructor(mcData) {
+        this.yawSpeed = 3.0;
+        this.pitchSpeed = 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
+        this.soulsandSpeed = 0.4;
+        this.honeyblockSpeed = 0.4;
+        this.honeyblockJumpSpeed = 0.4;
+        this.ladderMaxSpeed = 0.15;
+        this.ladderClimbSpeed = 0.2;
+        this.waterInertia = 0.8;
+        this.lavaInertia = 0.5;
+        this.liquidAcceleration = 0.02;
+        this.defaultSlipperiness = 0.6;
+        this.outOfLiquidImpulse = 0.3;
+        this.autojumpCooldown = 10; // ticks (0.5s)
+        this.bubbleColumnSurfaceDrag = {
+            down: 0.03,
+            maxDown: -0.9,
+            up: 0.1,
+            maxUp: 1.8,
+        };
+        this.bubbleColumnDrag = {
+            down: 0.03,
+            maxDown: -0.3,
+            up: 0.06,
+            maxUp: 0.7,
+        };
+        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;
+        this.mcData = mcData;
+        this.entityData = mcData["entitiesByName"];
+        this.mobData = mcData["mobs"];
+    }
+}
+exports.OPhysicsSettings = OPhysicsSettings;
 function load(data) {
     PhysicsSettings.mcData = data;
     PhysicsSettings.entityData = data["entitiesByName"];
     PhysicsSettings.mobData = data["mobs"];
 }
+/**
+ * @deprecated Use PlayerPhysicsSettings instead
+ */
 class PhysicsSettings {
 }
 exports.PhysicsSettings = PhysicsSettings;
@@ -42,7 +89,7 @@ PhysicsSettings.slowFalling = 0.125;
 PhysicsSettings.sprintingUUID = "662a6b8d-da3e-4c1c-8813-96ea6097278d"; // SPEED_MODIFIER_SPRINTING_UUID is from LivingEntity.java
 PhysicsSettings.jumpHeight = Math.fround(0.42);
 PhysicsSettings.airborneInertia = 0.99;
-PhysicsSettings.airborneAcceleration = 0.06;
+PhysicsSettings.airborneAcceleration = 0.02;
 PhysicsSettings.sprintSpeed = Math.fround(0.3);
 PhysicsSettings.sneakSpeed = 0.3;
 PhysicsSettings.usingItemSpeed = 0.2;

package/dist/wrapper.d.ts

@@ -1,5 +1,5 @@
 import { EntityPhysics, IPhysics } from "./physics/engines";
-import { EPhysicsCtx, PhysicsSettings } from "./physics/settings";
+import { EPhysicsCtx } from "./physics/settings";
 import { Vec3 } from "vec3";
 import md from "minecraft-data";
 import type { Entity } from "prismarine-entity";
@@ -15,7 +15,6 @@ export declare enum SimulationTypes {
 export declare class PhysicsUtilWrapper {
     private bot;
     engine: IPhysics;
-    readonly physicsSettings: typeof PhysicsSettings;
     readonly ePhysicsCtx: typeof EPhysicsCtx;
     readonly data: md.IndexedData;
     constructor(bot: Bot);

package/dist/wrapper.js

@@ -16,10 +16,8 @@ var SimulationTypes;
 class PhysicsUtilWrapper {
     constructor(bot) {
         this.bot = bot;
-        this.physicsSettings = settings_1.PhysicsSettings;
         this.ePhysicsCtx = settings_1.EPhysicsCtx;
         this.data = bot.registry;
-        settings_1.PhysicsSettings.loadData(this.data);
         settings_1.EPhysicsCtx.loadData(this.data);
         this.engine = new engines_1.EntityPhysics(this.data);
     }

package/package.json

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

package/tests/actualBot.ts

@@ -8,6 +8,7 @@ const bot: Bot = createBot({
   host: process.argv[2],
   port: Number(process.argv[3]),
   username: "testingbot",
+  version: process.argv[4],
 });
 
 bot.once("spawn", async () => {
@@ -24,13 +25,44 @@ const rl = require("readline").createInterface({
 
 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());
+  }
+  wasOnGround = bot.entity.onGround;
+});
+
+// print whenever another player hits the ground
+let lastPositions: Record<string, boolean> = {};
+bot.on("entityMoved", (entity) => {
+  console.log(entity.username)
+  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]) {
+      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;
+    }}
+});
+
 bot.on("chat", (user, message) => {
   const [cmd, ...args] = message.split(" ");
   const author = bot.nearestEntity((e) => e.username === user);
 
   switch (cmd) {
+    case "control":
+      if (args.length !== 2) return bot.chat("Invalid control command!");
+      if (args[0] === "clear") return bot.clearControlStates();
+      bot.setControlState(args[0] as any, args[1] === "true");
+      break;
     case "original":
       bot.physics = new Physics(bot.registry, bot.world);
+      bot.chat("Switched to original physics!");
       break;
     case "new":
       const val = new EntityPhysics(bot.registry);
@@ -54,6 +86,7 @@ bot.on("chat", (user, message) => {
         return val.simulate(ctx, bot.world);
         return oldSim(...args);
       };
+      bot.chat("Switched to new physics!");
       break;
     case "jump":
       bot.setControlState("jump", true);

package/tests/fakeWorld.ts

@@ -12,12 +12,14 @@ import expect from "expect";
 
 import { initSetup } from "../src/index";
 
-const mcData = md("1.17.1");
-const Block = (block as any)("1.17.1");
+const mcData = md("1.12.2");
+const Block = (block as any)("1.12.2");
+
+const groundLevel = 4;
 
 const fakeWorld = {
     getBlock: (pos: { x: number; y: number; z: number }) => {
-        const type = pos.y < 60 ? mcData.blocksByName.stone.id : mcData.blocksByName.air.id;
+        const type = pos.y < groundLevel ? mcData.blocksByName.stone.id : mcData.blocksByName.air.id;
         const b = new Block(type, 0, 0);
         b.position = pos;
         return b;
@@ -45,7 +47,7 @@ function createFakePlayer(pos: Vec3) {
             slots: [],
         },
 
-        setControlState: (...args) => {}
+        setControlState: (...args: any) => {}
     };
 }
 
@@ -55,7 +57,7 @@ initSetup(mcData);
 
 //create fake bot
 const playerType = mcData.entitiesByName["player"]; // specify type we will be simulating.
-const fakePlayer = createFakePlayer(new Vec3(0, 80, 0)); // call function supplied by prismarine-physics
+const fakePlayer = createFakePlayer(new Vec3(0, groundLevel + 20, 0)); // call function supplied by prismarine-physics
 fakePlayer.entity = applyMdToNewEntity(EPhysicsCtx, playerType, fakePlayer.entity); // ensure compatibility.
 
 // create physics context.
@@ -69,6 +71,7 @@ const playerCtx = EPhysicsCtx.FROM_ENTITY_STATE(physics, playerState, playerType
 playerState.control = ControlStateHandler.DEFAULT(); // specific to players and mobs, specify control scheme to apply.
 playerState.control.forward = true;
 
+
 // simulate until on ground.
 while (!playerCtx.state.onGround) {
     physics.simulate(playerCtx, fakeWorld).applyToBot(fakePlayer as any); // (applyToBot since fakePlayer is supposed to be a bot)
@@ -76,9 +79,9 @@ while (!playerCtx.state.onGround) {
 }
 
 if (playerState.control.forward) {
-    expect(fakePlayer.entity.position).toEqual(new Vec3(0, 60, -3.4508449226731694)); // it works.
+    expect(fakePlayer.entity.position).toEqual(new Vec3(0, groundLevel, -3.4508449226731694)); // it works.
 } else {
-    expect(fakePlayer.entity.position).toEqual(new Vec3(0, 60, 0)); // it works.
+    expect(fakePlayer.entity.position).toEqual(new Vec3(0, groundLevel, 0)); // it works.
 }
 
 playerCtx.state.control.set("jump", true);
@@ -88,9 +91,9 @@ for (let i = 0; i < 12; i++) {
 }
 
 if (playerState.control.forward) {
-    expect(fakePlayer.entity.position).toEqual(new Vec3(0, 60, -5.788782872583908)); // it works.
+    expect(fakePlayer.entity.position).toEqual(new Vec3(0, groundLevel, -5.788782872583908)); // it works.
 } else {
-    expect(fakePlayer.entity.position).toEqual(new Vec3(0, 60, 0)); // it works.
+    expect(fakePlayer.entity.position).toEqual(new Vec3(0, groundLevel, 0)); // it works.
 }