@nxg-org/mineflayer-physics-util 1.2.1

package/README.md

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

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+import type { IndexedData } from "minecraft-data";
+import type { Bot } from "mineflayer";
+import { PhysicsUtilWrapper } from "./wrapper";
+declare module "mineflayer" {
+    interface Bot {
+        physicsUtil: PhysicsUtilWrapper;
+    }
+}
+export default function loader(bot: Bot): void;
+export declare function initSetup(data: IndexedData): void;
+export { EPhysicsCtx, PhysicsSettings } from "./physics/settings";
+export { BaseSimulator } from "./simulators";
+export { IPhysics } from "./physics/engines";
+export { EntityState } from "./physics/states";

package/lib/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityState = exports.BaseSimulator = exports.PhysicsSettings = exports.EPhysicsCtx = exports.initSetup = void 0;
+const settings_1 = require("./physics/settings");
+const wrapper_1 = require("./wrapper");
+const prismarine_registry_1 = __importDefault(require("prismarine-registry"));
+function loader(bot) {
+    if (!bot.physicsUtil) {
+        initSetup((0, prismarine_registry_1.default)(bot.version));
+        bot.physicsUtil = new wrapper_1.PhysicsUtilWrapper(bot);
+        console.log(bot.physicsUtil);
+    }
+    console.log(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");
+Object.defineProperty(exports, "EPhysicsCtx", { enumerable: true, get: function () { return settings_2.EPhysicsCtx; } });
+Object.defineProperty(exports, "PhysicsSettings", { enumerable: true, get: function () { return settings_2.PhysicsSettings; } });
+var simulators_1 = require("./simulators");
+Object.defineProperty(exports, "BaseSimulator", { enumerable: true, get: function () { return simulators_1.BaseSimulator; } });
+var states_1 = require("./physics/states");
+Object.defineProperty(exports, "EntityState", { enumerable: true, get: function () { return states_1.EntityState; } });

package/lib/physics/engines/IPhysics.d.ts

@@ -0,0 +1,30 @@
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
+import { IndexedData } from "minecraft-data";
+import { Effect } from "mineflayer";
+import { Entity } from "prismarine-entity";
+import { PhysicsSettings } from "../settings/physicsSettings";
+import { EPhysicsCtx } from "../settings/entityPhysicsCtx";
+import { CheapEffects, CheapEnchantments, makeSupportFeature } from "../../util/physicsUtils";
+import { EntityState } from "../states";
+export declare type MobsByName = {
+    [mobName: string]: Entity;
+};
+export interface IPhysics {
+    settings: PhysicsSettings;
+    perEntityCtx: typeof EPhysicsCtx;
+    data: IndexedData;
+    supportFeature: ReturnType<typeof makeSupportFeature>;
+    getEffectLevel: (effect: string, effects: Effect[]) => number;
+    getEnchantmentLevel: (effect: string, enchantments: any[]) => number;
+    getEffectLevelCustom: (effect: CheapEffects, effects: Effect[]) => number;
+    getEnchantmentLevelCustom: (effect: CheapEnchantments, enchantments: any[]) => number;
+    getUnderlyingBlockBBs(queryBB: AABB, world: any): AABB[];
+    getSurroundingBBs(queryBB: AABB, world: any): AABB[];
+    simulatePlayer(simCtx: EPhysicsCtx, world: any): EntityState;
+    readonly statusEffectNames: {
+        [type in CheapEffects]: string;
+    };
+    readonly enchantmentNames: {
+        [type in CheapEnchantments]: string;
+    };
+}

package/lib/physics/engines/IPhysics.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/physics/engines/entityPhysics.d.ts

@@ -0,0 +1,90 @@
+import { Vec3 } from "vec3";
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
+import md from "minecraft-data";
+import { Effect, Entity } from "prismarine-entity";
+import { Block } from "prismarine-block";
+import { NormalizedEnchant } from "prismarine-item";
+import { CheapEffects, CheapEnchantments, makeSupportFeature } from "../../util/physicsUtils";
+import { EntityState } from "../states/entityState";
+import { IPhysics } from "./IPhysics";
+import { PhysicsSettings } from "../settings/physicsSettings";
+import { EPhysicsCtx } from "../settings/entityPhysicsCtx";
+/**
+ * Looking at this code, it's too specified towards players.
+ *
+ * I will eventually split this code into PlayerState and bot.entityState, where bot.entityState contains fewer controls.
+ */
+export declare class EntityPhysics<T extends md.Entity> implements IPhysics {
+    data: md.IndexedData;
+    entity: T;
+    movementSpeedAttribute: any;
+    supportFeature: ReturnType<typeof makeSupportFeature>;
+    blockSlipperiness: {
+        [name: string]: number;
+    };
+    protected slimeBlockId: number;
+    protected soulsandId: number;
+    protected honeyblockId: number;
+    protected webId: number;
+    protected waterId: number;
+    protected lavaId: number;
+    protected ladderId: number;
+    protected vineId: number;
+    protected bubblecolumnId: number;
+    protected waterLike: Set<number>;
+    readonly statusEffectNames: {
+        [type in CheapEffects]: string;
+    };
+    readonly enchantmentNames: {
+        [type in CheapEnchantments]: string;
+    };
+    settings: PhysicsSettings;
+    perEntityCtx: typeof EPhysicsCtx;
+    constructor(mcData: md.IndexedData, entity: T);
+    static FROM_ENTITY(mcData: md.IndexedData, entity: Entity): EntityPhysics<md.Entity>;
+    getPlayerBB(entity: EPhysicsCtx, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): AABB;
+    setPositionToBB(entity: EPhysicsCtx, bb: AABB, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    getUnderlyingBlockBBs(queryBB: AABB, world: any): AABB[];
+    getSurroundingBBs(queryBB: AABB, world: any): AABB[];
+    adjustPositionHeight(entity: EPhysicsCtx, pos: Vec3, world: any): void;
+    moveEntity(entity: EPhysicsCtx, dx: number, dy: number, dz: number, world: any): void;
+    applyHeading(entity: EPhysicsCtx, strafe: number, forward: number, multiplier: number): Vec3 | undefined;
+    getEffectLevelCustom(wantedEffect: CheapEffects, effects: Effect[]): number;
+    getEnchantmentLevelCustom(wantedEnchantment: CheapEnchantments, enchantments: any[]): any;
+    getEffectLevel(effectName: string, effects: Effect[]): number;
+    /**
+     * Slightly modified since I cannot find the typing.
+     */
+    getEnchantmentLevelTest(enchantmentName: string, enchantments: NormalizedEnchant[]): number;
+    getEnchantmentLevel(enchantmentName: string, enchantments: any[]): any;
+    isOnLadder(pos: {
+        x: number;
+        y: number;
+        z: number;
+    }, world: any): any;
+    doesNotCollide(entity: EPhysicsCtx, pos: {
+        x: number;
+        y: number;
+        z: number;
+    }, world: any): boolean;
+    isMaterialInBB(queryBB: AABB, type: number, world: any): boolean;
+    getWaterInBB(bb: AABB, world: any): any[];
+    getLiquidHeightPcent(block: Block): number;
+    getRenderedDepth(block: Block): number;
+    getFlow(block: Block, world: any): Vec3;
+    isInWaterApplyCurrent(bb: AABB, vel: {
+        x: number;
+        y: number;
+        z: number;
+    }, world: any): boolean;
+    moveEntityWithHeading(entity: EPhysicsCtx, strafe: number, forward: number, world: any): void;
+    simulatePlayer(entity: EPhysicsCtx, world: any): EntityState;
+}