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

package/dist/index.d.ts

@@ -11,6 +11,6 @@ export declare function initSetup(data: IndexedData): void;
 export { EPhysicsCtx, PhysicsWorldSettings } from "./physics/settings";
 export { BaseSimulator } from "./simulators";
 export { EntityPhysics, BotcraftPhysics } from "./physics/engines";
-export { EntityState } from "./physics/states";
+export { EntityState, PlayerState, PlayerPoses, IEntityState } from "./physics/states";
 export { ControlStateHandler } from "./physics/player";
 export type { SimulationGoal, Controller, OnGoalReachFunction } from "./simulators";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlStateHandler = exports.EntityState = exports.BotcraftPhysics = exports.EntityPhysics = exports.BaseSimulator = exports.PhysicsWorldSettings = exports.EPhysicsCtx = void 0;
+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");
@@ -24,5 +24,7 @@ Object.defineProperty(exports, "EntityPhysics", { enumerable: true, get: functio
 Object.defineProperty(exports, "BotcraftPhysics", { enumerable: true, get: function () { return engines_1.BotcraftPhysics; } });
 var states_1 = require("./physics/states");
 Object.defineProperty(exports, "EntityState", { enumerable: true, get: function () { return states_1.EntityState; } });
+Object.defineProperty(exports, "PlayerState", { enumerable: true, get: function () { return states_1.PlayerState; } });
+Object.defineProperty(exports, "PlayerPoses", { enumerable: true, get: function () { return states_1.PlayerPoses; } });
 var player_1 = require("./physics/player");
 Object.defineProperty(exports, "ControlStateHandler", { enumerable: true, get: function () { return player_1.ControlStateHandler; } });

package/dist/simulators/baseSimulator.d.ts

@@ -4,19 +4,19 @@ import { EntityState, IEntityState } from "../physics/states";
 import { IPhysics } from "../physics/engines";
 import { Entity } from "prismarine-entity";
 import { Vec3 } from "vec3";
-export type SimulationGoal = (state: IEntityState, ticks: number) => boolean | ((state: IEntityState) => boolean);
-export type OnGoalReachFunction = (state: IEntityState) => void;
-export type Controller = (state: IEntityState, ticks: number) => void;
-export declare class BaseSimulator {
+export type SimulationGoal<State extends IEntityState = IEntityState> = (state: State, ticks: number) => boolean | ((state: State) => boolean);
+export type OnGoalReachFunction<State extends IEntityState = IEntityState> = (state: State) => void;
+export type Controller<State extends IEntityState = IEntityState> = (state: State, ticks: number) => void;
+export declare class BaseSimulator<State extends IEntityState = IEntityState> {
     readonly ctx: IPhysics;
     constructor(ctx: IPhysics);
-    predictGenerator(simCtx: EPhysicsCtx, world: any, ticks?: number, controls?: ControlStateHandler): Generator<IEntityState, EPhysicsCtx<IEntityState>, unknown>;
+    predictGenerator(simCtx: EPhysicsCtx<State>, world: any, ticks?: number, controls?: ControlStateHandler): Generator<IEntityState, EPhysicsCtx<State>, 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;
-    static getCleanupPosition(...path: Vec3[]): OnGoalReachFunction;
-    static buildFullController(...controllers: Controller[]): Controller;
-    static buildAnyGoal(...goals: SimulationGoal[]): SimulationGoal;
-    static buildAllGoal(...goals: SimulationGoal[]): SimulationGoal;
+    predictForwardRaw(simCtx: EPhysicsCtx<State>, world: any, ticks?: number, controls?: ControlStateHandler): State;
+    simulateUntil(goal: SimulationGoal, onGoalReach: OnGoalReachFunction, controller: Controller, simCtx: EPhysicsCtx<State>, world: any, ticks?: number): State;
+    static getReached<State extends IEntityState = IEntityState>(...path: Vec3[]): SimulationGoal<State>;
+    static getCleanupPosition<State extends IEntityState = IEntityState>(...path: Vec3[]): OnGoalReachFunction<State>;
+    static buildFullController<State extends IEntityState = IEntityState>(...controllers: Controller<State>[]): Controller<State>;
+    static buildAnyGoal<State extends IEntityState = IEntityState>(...goals: SimulationGoal<State>[]): SimulationGoal<State>;
+    static buildAllGoal<State extends IEntityState = IEntityState>(...goals: SimulationGoal<State>[]): SimulationGoal<State>;
 }

package/dist/simulators/basicSim.d.ts

@@ -1,19 +1,12 @@
-import { Entity } from "prismarine-entity";
 import { IPhysics } from "../physics/engines";
 import { EPhysicsCtx } from "../physics/settings";
 import { Vec3 } from "vec3";
 import { BaseSimulator } from "./baseSimulator";
-import md from "minecraft-data";
-export declare class BasicSim extends BaseSimulator {
+import { IEntityState } from "../physics/states";
+export declare class BasicSim<State extends IEntityState = IEntityState> extends BaseSimulator<State> {
     readonly ctx: IPhysics;
     constructor(ctx: IPhysics);
-    simXTicksRaw(mdEntity: md.Entity, world: any, ticks?: number, options?: Partial<Entity>): import("../physics/states").IEntityState;
-    simXTicks(entity: Entity, world: any, ticks: number): import("../physics/states").IEntityState;
-    simXTicksPrebuilt(ctx: EPhysicsCtx, world: any, ticks: number): import("../physics/states").IEntityState;
-    simUntilOnGroundRaw(mdEntity: md.Entity, world: any, ticks?: number, options?: Partial<Entity>): import("../physics/states").IEntityState;
-    simUntilOnGround(entity: Entity, world: any, ticks?: number): import("../physics/states").IEntityState;
-    simUntilOnGroundPrebuilt(ctx: EPhysicsCtx, world: any, ticks?: number): import("../physics/states").IEntityState;
-    simUntilDestinationRaw(mdEntity: md.Entity, destination: Vec3, world: any, ticks?: number, options?: Partial<Entity>): import("../physics/states").IEntityState;
-    simUntilDestination(entity: Entity, destination: Vec3, world: any, ticks?: number): import("../physics/states").IEntityState;
-    simUntilDestinationPrebuilt(ctx: EPhysicsCtx, destination: Vec3, world: any, ticks?: number): import("../physics/states").IEntityState;
+    simXTicksPrebuilt(ctx: EPhysicsCtx<State>, world: any, ticks: number): State;
+    simUntilOnGroundPrebuilt(ctx: EPhysicsCtx<State>, world: any, ticks?: number): State;
+    simUntilDestinationPrebuilt(ctx: EPhysicsCtx<State>, destination: Vec3, world: any, ticks?: number): State;
 }

package/dist/simulators/basicSim.js

@@ -1,38 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BasicSim = void 0;
-const physicsUtils_1 = require("../util/physicsUtils");
-const settings_1 = require("../physics/settings");
 const baseSimulator_1 = require("./baseSimulator");
 class BasicSim extends baseSimulator_1.BaseSimulator {
     constructor(ctx) {
         super(ctx);
         this.ctx = ctx;
     }
-    simXTicksRaw(mdEntity, world, ticks = 5, options = {}) {
-        return this.simXTicks((0, physicsUtils_1.applyMdToNewEntity)(settings_1.EPhysicsCtx, mdEntity, options), world, ticks);
-    }
-    simXTicks(entity, world, ticks) {
-        return this.simulateUntil((state) => false, () => { }, () => { }, settings_1.EPhysicsCtx.FROM_ENTITY(this.ctx, entity), world, ticks);
-    }
+    // public simXTicksRaw(mdEntity: md.Entity, world: any, ticks: number = 5, options: Partial<Entity> = {}) {
+    //     return this.simXTicks(applyMdToNewEntity(EPhysicsCtx, mdEntity, options), world, ticks);
+    // }
+    // public simXTicks(entity: Entity, world: any, ticks: number) {
+    //     return this.simulateUntil(
+    //         (state) => false,
+    //         () => {},
+    //         () => {},
+    //         EPhysicsCtx.FROM_ENTITY(this.ctx, entity),
+    //         world,
+    //         ticks
+    //     );
+    // }
     simXTicksPrebuilt(ctx, world, ticks) {
         return this.simulateUntil((state) => false, () => { }, () => { }, ctx, world, ticks);
     }
-    simUntilOnGroundRaw(mdEntity, world, ticks = 5, options = {}) {
-        return this.simUntilOnGround((0, physicsUtils_1.applyMdToNewEntity)(settings_1.EPhysicsCtx, mdEntity, options), world, ticks);
-    }
-    simUntilOnGround(entity, world, ticks = 5) {
-        return this.simulateUntil((state) => state.onGround === true, () => { }, () => { }, settings_1.EPhysicsCtx.FROM_ENTITY(this.ctx, entity), world, ticks);
-    }
+    // public simUntilOnGroundRaw(mdEntity: md.Entity, world: any, ticks: number = 5, options: Partial<Entity> = {}) {
+    //     return this.simUntilOnGround(applyMdToNewEntity(EPhysicsCtx, mdEntity, options), world, ticks);
+    // }
+    // public simUntilOnGround(entity: Entity, world: any, ticks: number = 5) {
+    //     return this.simulateUntil(
+    //         (state) => state.onGround === true,
+    //         () => {},
+    //         () => {},
+    //         EPhysicsCtx.FROM_ENTITY(this.ctx, entity),
+    //         world,
+    //         ticks
+    //     );
+    // }
     simUntilOnGroundPrebuilt(ctx, world, ticks = 5) {
         return this.simulateUntil((state) => state.onGround === true, () => { }, () => { }, ctx, world, ticks);
     }
-    simUntilDestinationRaw(mdEntity, destination, world, ticks = 5, options = {}) {
-        return this.simUntilDestination((0, physicsUtils_1.applyMdToNewEntity)(settings_1.EPhysicsCtx, mdEntity, options), destination, world, ticks);
-    }
-    simUntilDestination(entity, destination, world, ticks = 10) {
-        return this.simulateUntil(BasicSim.getReached(destination), () => { }, () => { }, settings_1.EPhysicsCtx.FROM_ENTITY(this.ctx, entity), world, ticks);
-    }
+    // public simUntilDestinationRaw(mdEntity: md.Entity, destination: Vec3, world: any, ticks: number = 5, options: Partial<Entity> = {}) {
+    //     return this.simUntilDestination(applyMdToNewEntity(EPhysicsCtx, mdEntity, options), destination, world, ticks);
+    // }
+    // public simUntilDestination(entity: Entity, destination: Vec3, world: any, ticks: number = 10) {
+    //     return this.simulateUntil(
+    //         BasicSim.getReached(destination),
+    //         () => {},
+    //         () => {},
+    //         EPhysicsCtx.FROM_ENTITY(this.ctx, entity),
+    //         world,
+    //         ticks
+    //     );
+    // }
     simUntilDestinationPrebuilt(ctx, destination, world, ticks = 10) {
         return this.simulateUntil(BasicSim.getReached(destination), () => { }, () => { }, ctx, world, ticks);
     }

package/dist/wrapper.d.ts

@@ -1,17 +1,8 @@
 import { EntityPhysics, IPhysics } from "./physics/engines";
 import { EPhysicsCtx } from "./physics/settings";
-import { Vec3 } from "vec3";
 import md from "minecraft-data";
 import type { Entity } from "prismarine-entity";
 import type { Bot } from "mineflayer";
-/**
- * Just a convenience thing.
- */
-export declare enum SimulationTypes {
-    UNTIL_GROUND = 0,
-    FOR_X_TICKS = 1,
-    TO_DESTINATION = 2
-}
 export declare class PhysicsUtilWrapper {
     private bot;
     engine: IPhysics;
@@ -21,7 +12,4 @@ export declare class PhysicsUtilWrapper {
     getPhysicsSim(): EntityPhysics;
     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/dist/wrapper.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhysicsUtilWrapper = exports.SimulationTypes = void 0;
+exports.PhysicsUtilWrapper = void 0;
 const engines_1 = require("./physics/engines");
 const settings_1 = require("./physics/settings");
-const simulators_1 = require("./simulators");
-/**
- * Just a convenience thing.
- */
-var SimulationTypes;
-(function (SimulationTypes) {
-    SimulationTypes[SimulationTypes["UNTIL_GROUND"] = 0] = "UNTIL_GROUND";
-    SimulationTypes[SimulationTypes["FOR_X_TICKS"] = 1] = "FOR_X_TICKS";
-    SimulationTypes[SimulationTypes["TO_DESTINATION"] = 2] = "TO_DESTINATION";
-})(SimulationTypes || (exports.SimulationTypes = SimulationTypes = {}));
+// /**
+//  * Just a convenience thing.
+//  */
+// export enum SimulationTypes {
+//     UNTIL_GROUND,
+//     FOR_X_TICKS,
+//     TO_DESTINATION,
+// }
 class PhysicsUtilWrapper {
     constructor(bot) {
         this.bot = bot;
@@ -30,34 +28,5 @@ class PhysicsUtilWrapper {
     getPhysicsCtxRaw(ctx, entity, options = {}) {
         return settings_1.EPhysicsCtx.FROM_ENTITY_TYPE(ctx, entity, options);
     }
-    simulate(simulator, simCtx, world) {
-        return simulator.simulate(simCtx, world);
-    }
-    exampleSim(entity, type, ticks = 10, destination) {
-        const simulator = new simulators_1.BasicSim(new engines_1.EntityPhysics(this.data));
-        switch (type) {
-            case SimulationTypes.FOR_X_TICKS:
-                return simulator.simXTicks(entity, this.bot.world, ticks);
-            case SimulationTypes.UNTIL_GROUND:
-                return simulator.simUntilOnGround(entity, this.bot.world, ticks);
-            case SimulationTypes.TO_DESTINATION:
-                if (!destination)
-                    throw "Invalid destination for example sim.";
-                return simulator.simUntilDestination(entity, destination, this.bot.world, ticks);
-        }
-    }
-    advancedExample(simCtx, type, ticks = 10, destination) {
-        const simulator = new simulators_1.BasicSim(new engines_1.EntityPhysics(this.data));
-        switch (type) {
-            case SimulationTypes.FOR_X_TICKS:
-                return simulator.simXTicksPrebuilt(simCtx, this.bot.world, ticks);
-            case SimulationTypes.UNTIL_GROUND:
-                return simulator.simUntilOnGroundPrebuilt(simCtx, this.bot.world, ticks);
-            case SimulationTypes.TO_DESTINATION:
-                if (!destination)
-                    throw "Invalid destination for example sim.";
-                return simulator.simUntilDestinationPrebuilt(simCtx, destination, this.bot.world, ticks);
-        }
-    }
 }
 exports.PhysicsUtilWrapper = PhysicsUtilWrapper;

package/package.json

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