@nxg-org/mineflayer-physics-util 1.8.10 → 1.8.12

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

@@ -4,19 +4,20 @@ import type { Bot } from "mineflayer";
 import { Entity } from "prismarine-entity";
 import { Vec3 } from "vec3";
 import { IPhysics } from "../engines/IPhysics";
-import { IEntityState } from "../states";
+import { EntityState, IEntityState } from "../states";
 import { PlayerPoses } from "../states/poses";
 import { PhysicsWorldSettings } from "./physicsSettings";
+import { PlayerState } from "../states";
 export declare const emptyVec: Vec3;
 type CollisionContext = {
     blockEffects: boolean;
     affectedAfterCollision: boolean;
 };
-export declare class EPhysicsCtx {
+export declare class EPhysicsCtx<State extends IEntityState = IEntityState> {
     readonly ctx: IPhysics;
     readonly worldSettings: PhysicsWorldSettings;
     pose: PlayerPoses;
-    readonly state: IEntityState;
+    readonly state: State;
     readonly entityType: md.Entity;
     static loadData: (data: md.IndexedData) => void;
     static entityConstructor: new (id: number) => Entity;
@@ -41,12 +42,12 @@ export declare class EPhysicsCtx {
     doSolidCollisions: boolean;
     doLiquidCollisions: boolean;
     collisionBehavior: CollisionContext;
-    constructor(ctx: IPhysics, worldSettings: PhysicsWorldSettings, pose: PlayerPoses, state: IEntityState, 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: IEntityState, entityType?: md.Entity, settings?: PhysicsWorldSettings): EPhysicsCtx;
-    clone(): EPhysicsCtx;
+    constructor(ctx: IPhysics, worldSettings: PhysicsWorldSettings, pose: PlayerPoses, state: State, entityType?: md.Entity);
+    static FROM_BOT(ctx: IPhysics, bot: Bot, settings?: PhysicsWorldSettings): EPhysicsCtx<PlayerState>;
+    static FROM_ENTITY(ctx: IPhysics, entity: Entity, settings?: PhysicsWorldSettings): EPhysicsCtx<EntityState>;
+    static FROM_ENTITY_TYPE(ctx: IPhysics, entityType: md.Entity, options?: Partial<Entity>, settings?: PhysicsWorldSettings): EPhysicsCtx<EntityState>;
+    static FROM_ENTITY_STATE(ctx: IPhysics, entityState: IEntityState, entityType?: md.Entity, settings?: PhysicsWorldSettings): EPhysicsCtx<IEntityState>;
+    clone(): EPhysicsCtx<IEntityState>;
     get height(): number;
     get width(): number;
     getHalfWidth(): number;

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

@@ -2,6 +2,7 @@ import type { Effect, Entity } from "prismarine-entity";
 import type { Vec3 } from "vec3";
 import { PlayerPoses } from "./poses";
 import { ControlStateHandler } from "../states";
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
 export * from "./entityState";
 export * from "./playerState";
 export * from "./poses";
@@ -44,5 +45,6 @@ export interface IEntityState {
     jumpQueued: boolean;
     supportingBlockPos: Vec3 | null;
     clone(): IEntityState;
+    getBB(): AABB;
 }
 export declare function getPose(entity: Entity): number;

package/dist/simulators/baseSimulator.d.ts

@@ -1,6 +1,6 @@
 import { ControlStateHandler } from "../physics/player";
 import { EPhysicsCtx } from "../physics/settings";
-import { IEntityState } from "../physics/states";
+import { EntityState, IEntityState } from "../physics/states";
 import { IPhysics } from "../physics/engines";
 import { Entity } from "prismarine-entity";
 import { Vec3 } from "vec3";
@@ -10,8 +10,8 @@ export type Controller = (state: IEntityState, ticks: number) => void;
 export declare class BaseSimulator {
     readonly ctx: IPhysics;
     constructor(ctx: IPhysics);
-    predictGenerator(simCtx: EPhysicsCtx, world: any, ticks?: number, controls?: ControlStateHandler): Generator<IEntityState, EPhysicsCtx, unknown>;
-    predictForward(target: Entity, world: any, ticks?: number, controls?: ControlStateHandler): IEntityState;
+    predictGenerator(simCtx: EPhysicsCtx, world: any, ticks?: number, controls?: ControlStateHandler): Generator<IEntityState, EPhysicsCtx<IEntityState>, unknown>;
+    predictForward(target: Entity, world: any, ticks?: number, controls?: ControlStateHandler): EntityState;
     predictForwardRaw(simCtx: EPhysicsCtx, world: any, ticks?: number, controls?: ControlStateHandler): IEntityState;
     simulateUntil(goal: SimulationGoal, onGoalReach: OnGoalReachFunction, controller: Controller, simCtx: EPhysicsCtx, world: any, ticks?: number): IEntityState;
     static getReached(...path: Vec3[]): SimulationGoal;

package/dist/wrapper.d.ts

@@ -19,8 +19,8 @@ export declare class PhysicsUtilWrapper {
     readonly data: md.IndexedData;
     constructor(bot: Bot);
     getPhysicsSim(): EntityPhysics;
-    getPhysicsCtx(ctx: IPhysics, entity: Entity): EPhysicsCtx;
-    getPhysicsCtxRaw(ctx: IPhysics, entity: md.Entity, options?: Partial<Entity>): EPhysicsCtx;
+    getPhysicsCtx(ctx: IPhysics, entity: Entity): EPhysicsCtx<import(".").EntityState>;
+    getPhysicsCtxRaw(ctx: IPhysics, entity: md.Entity, options?: Partial<Entity>): EPhysicsCtx<import(".").EntityState>;
     simulate(simulator: IPhysics, simCtx: EPhysicsCtx, world: any): import("./physics/states").IEntityState;
     exampleSim(entity: Entity, type: SimulationTypes, ticks?: number, destination?: Vec3): import("./physics/states").IEntityState;
     advancedExample(simCtx: EPhysicsCtx, type: SimulationTypes, ticks?: number, destination?: Vec3): import("./physics/states").IEntityState;

package/package.json

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