@nxg-org/mineflayer-physics-util 1.2.1

package/lib/physics/settings/physicsSettings.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhysicsSettings = void 0;
+function load(data) {
+    PhysicsSettings.mcData = data;
+    PhysicsSettings.entityData = data["entitiesByName"];
+    PhysicsSettings.mobData = data["mobs"];
+}
+class PhysicsSettings {
+    constructor(ctx, gravity, terminalVelocity, airdrag, airborneInertia, airborneAcceleration, dragAfterAcceleration = false, useControls = false, sprintSpeed = 0.3, sneakSpeed = 0.3, usingItemSpeed = 0.2) {
+        this.ctx = ctx;
+        this.gravity = gravity;
+        this.terminalVelocity = terminalVelocity;
+        this.airdrag = airdrag;
+        this.airborneInertia = airborneInertia;
+        this.airborneAcceleration = airborneAcceleration;
+        this.dragAfterAcceleration = dragAfterAcceleration;
+        this.useControls = useControls;
+        this.sprintSpeed = sprintSpeed;
+        this.sneakSpeed = sneakSpeed;
+        this.usingItemSpeed = usingItemSpeed;
+        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.movementSpeedAttribute = ctx.data.attributesByName.movementSpeed.resource;
+        if (ctx.supportFeature("independentLiquidGravity")) {
+            this.waterGravity = 0.02;
+            this.lavaGravity = 0.02;
+        }
+        else if (ctx.supportFeature("proportionalLiquidGravity")) {
+            this.waterGravity = this.gravity / 16;
+            this.lavaGravity = this.gravity / 4;
+        }
+        else {
+            this.waterGravity = 0.005;
+            this.lavaGravity = 0.02;
+        }
+    }
+    // entities: IndexedData["entitiesByName"],
+    //TODO: Perhaps get from type? Import indexedData to do it?
+    static FROM_ENTITY(ctx, baseEntity) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        switch (baseEntity.type) {
+            case "player":
+                return new PhysicsSettings(ctx, 0.08, 3.92, Math.fround(1 - 0.02), 0.91, 0.02, true, true);
+            case "mob":
+                return new PhysicsSettings(ctx, 0.08, 3.92, Math.fround(1 - 0.02), 0.91, 0.02);
+            case "orb":
+                return new PhysicsSettings(ctx, 0.03, 1.5, Math.fround(1 - 0.02), 0.91, 0.02);
+            case "other":
+                if (((_a = baseEntity.name) === null || _a === void 0 ? void 0 : _a.includes("block")) || ((_b = baseEntity.name) === null || _b === void 0 ? void 0 : _b.includes("tnt"))) {
+                    return new PhysicsSettings(ctx, 0.04, 2.0, Math.fround(1 - 0.02), 0.91, 0.02);
+                }
+                else if ((_c = baseEntity.name) === null || _c === void 0 ? void 0 : _c.includes("minecart")) {
+                    return new PhysicsSettings(ctx, 0.04, 0.76, Math.fround(1 - 0.05), 0.91, 0.02);
+                }
+                else if ((_d = baseEntity.name) === null || _d === void 0 ? void 0 : _d.includes("boat")) {
+                    return new PhysicsSettings(ctx, 0.04, Infinity, 0, 0.91, 0.02);
+                }
+                else if (((_e = baseEntity.name) === null || _e === void 0 ? void 0 : _e.includes("egg")) ||
+                    ((_f = baseEntity.name) === null || _f === void 0 ? void 0 : _f.includes("snowball")) ||
+                    ((_g = baseEntity.name) === null || _g === void 0 ? void 0 : _g.includes("potion")) ||
+                    ((_h = baseEntity.name) === null || _h === void 0 ? void 0 : _h.includes("pearl"))) {
+                    return new PhysicsSettings(ctx, 0.03, 3.0, Math.fround(1 - 0.01), 0.91, 0.02);
+                }
+                else if ((_j = baseEntity.name) === null || _j === void 0 ? void 0 : _j.includes("orb")) {
+                    return new PhysicsSettings(ctx, 0.03, 1.5, Math.fround(1 - 0.02), 0.91, 0.02);
+                }
+                else if ((_k = baseEntity.name) === null || _k === void 0 ? void 0 : _k.includes("bobber")) {
+                    return new PhysicsSettings(ctx, 0.03, 0.375, Math.fround(1 - 0.08), 0.91, 0.02);
+                }
+                else if ((_l = baseEntity.name) === null || _l === void 0 ? void 0 : _l.includes("spit")) {
+                    return new PhysicsSettings(ctx, 0.06, 6.0, Math.fround(1 - 0.01), 0.91, 0.02);
+                }
+                else if (((_m = baseEntity.name) === null || _m === void 0 ? void 0 : _m.includes("arrow")) || ((_o = baseEntity.name) === null || _o === void 0 ? void 0 : _o.includes("trident"))) {
+                    return new PhysicsSettings(ctx, 0.05, 5.0, Math.fround(1 - 0.01), 0.91, 0.02);
+                }
+                else if (((_p = baseEntity.name) === null || _p === void 0 ? void 0 : _p.includes("fireball")) || ((_q = baseEntity.name) === null || _q === void 0 ? void 0 : _q.includes("skull"))) {
+                    return new PhysicsSettings(ctx, 0.0, 1.9, Math.fround(1 - 0.05), 0.91, 0.02, true);
+                }
+        }
+        return new PhysicsSettings(ctx, 0.08, 3.92, Math.fround(1 - 0.02), 0.91, 0.02, true, true);
+    }
+    static FROM_MD_ENTITY(ctx, mdEntity) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        if (mdEntity.type === "player" || !!PhysicsSettings.mobData[mdEntity.id]) {
+            return new PhysicsSettings(ctx, 0.08, 3.92, Math.fround(1 - 0.02), 0.91, 0.02, true, true);
+        }
+        if ((_a = mdEntity.name) === null || _a === void 0 ? void 0 : _a.includes("experience_bottle")) {
+            return new PhysicsSettings(ctx, 0.06, 6.0, Math.fround(1 - 0.01), 0.91, 0.02);
+        }
+        if ((_b = mdEntity.name) === null || _b === void 0 ? void 0 : _b.includes("spit")) {
+            return new PhysicsSettings(ctx, 0.06, 6.0, Math.fround(1 - 0.01), 0.91, 0.02);
+        }
+        switch (mdEntity.type) {
+            case "water_creature":
+            case "animal":
+            case "hostile":
+            case "mob":
+                return new PhysicsSettings(ctx, 0.08, 3.92, Math.fround(1 - 0.02), 0.91, 0.02, true, true);
+            case "projectile":
+                return new PhysicsSettings(ctx, 0.03, 3.0, Math.fround(1 - 0.01), 0.91, 0.02);
+            case "orb":
+                return new PhysicsSettings(ctx, 0.03, 1.5, Math.fround(1 - 0.02), 0.91, 0.02);
+            case "other":
+                if ((_c = mdEntity.name) === null || _c === void 0 ? void 0 : _c.includes("minecart")) {
+                    return new PhysicsSettings(ctx, 0.04, 0.76, Math.fround(1 - 0.05), 0.91, 0.02);
+                }
+                else if (((_d = mdEntity.name) === null || _d === void 0 ? void 0 : _d.includes("block")) || ((_e = mdEntity.name) === null || _e === void 0 ? void 0 : _e.includes("tnt"))) {
+                    return new PhysicsSettings(ctx, 0.04, 2.0, Math.fround(1 - 0.02), 0.91, 0.02);
+                }
+                else if ((_f = mdEntity.name) === null || _f === void 0 ? void 0 : _f.includes("boat")) {
+                    return new PhysicsSettings(ctx, 0.04, Infinity, 0, 0.91, 0.02);
+                }
+                else if (((_g = mdEntity.name) === null || _g === void 0 ? void 0 : _g.includes("egg")) ||
+                    ((_h = mdEntity.name) === null || _h === void 0 ? void 0 : _h.includes("snowball")) ||
+                    ((_j = mdEntity.name) === null || _j === void 0 ? void 0 : _j.includes("potion")) ||
+                    ((_k = mdEntity.name) === null || _k === void 0 ? void 0 : _k.includes("pearl"))) {
+                    return new PhysicsSettings(ctx, 0.03, 3.0, Math.fround(1 - 0.01), 0.91, 0.02);
+                }
+                else if ((_l = mdEntity.name) === null || _l === void 0 ? void 0 : _l.includes("orb")) {
+                    return new PhysicsSettings(ctx, 0.03, 1.5, Math.fround(1 - 0.02), 0.91, 0.02);
+                }
+                else if ((_m = mdEntity.name) === null || _m === void 0 ? void 0 : _m.includes("bobber")) {
+                    return new PhysicsSettings(ctx, 0.03, 0.375, Math.fround(1 - 0.08), 0.91, 0.02);
+                }
+                else if ((_o = mdEntity.name) === null || _o === void 0 ? void 0 : _o.includes("spit")) {
+                    return new PhysicsSettings(ctx, 0.06, 6.0, Math.fround(1 - 0.01), 0.91, 0.02);
+                }
+                else if (((_p = mdEntity.name) === null || _p === void 0 ? void 0 : _p.includes("arrow")) || ((_q = mdEntity.name) === null || _q === void 0 ? void 0 : _q.includes("trident"))) {
+                    return new PhysicsSettings(ctx, 0.05, 5.0, Math.fround(1 - 0.01), 0.91, 0.02);
+                }
+                else if (((_r = mdEntity.name) === null || _r === void 0 ? void 0 : _r.includes("fireball")) || ((_s = mdEntity.name) === null || _s === void 0 ? void 0 : _s.includes("skull"))) {
+                    return new PhysicsSettings(ctx, 0.0, 1.9, Math.fround(1 - 0.05), 0.91, 0.02, true);
+                }
+        }
+        return new PhysicsSettings(ctx, 0.08, 3.92, Math.fround(1 - 0.02), 0.91, 0.02, true, true);
+    }
+}
+exports.PhysicsSettings = PhysicsSettings;
+PhysicsSettings.loadData = load;

package/lib/physics/states/entityState.d.ts

@@ -0,0 +1,95 @@
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
+import type { Entity } from "prismarine-entity";
+import type { Bot, Effect } from "mineflayer";
+import { Vec3 } from "vec3";
+import { ControlStateHandler } from "../player/playerControls";
+import { PlayerState } from "./playerState";
+import { PlayerPoses } from "./poses";
+import { IPhysics } from "../engines";
+export interface EntityStateBuilder {
+    height: number;
+    halfWidth: number;
+    position: Vec3;
+    velocity: Vec3;
+    pitch: number;
+    yaw: number;
+    controlState: ControlStateHandler;
+    onGround: boolean;
+    isUsingItem?: boolean;
+    isInWater?: boolean;
+    isInLava?: boolean;
+    isInWeb?: boolean;
+    sneakCollision?: boolean;
+    isCollidedHorizontally?: boolean;
+    isCollidedVertically?: boolean;
+    effects?: Effect[];
+    jumpBoost?: number;
+    speed?: number;
+    slowness?: number;
+    dolphinsGrace?: number;
+    slowFalling?: number;
+    levitation?: number;
+    depthStrider?: number;
+}
+export declare class EntityState implements EntityStateBuilder {
+    ctx: IPhysics;
+    height: number;
+    halfWidth: number;
+    position: Vec3;
+    velocity: Vec3;
+    onGround: boolean;
+    controlState: ControlStateHandler;
+    yaw: number;
+    pitch: number;
+    age: number;
+    isInWater: boolean;
+    isInLava: boolean;
+    isInWeb: boolean;
+    isCollidedHorizontally: boolean;
+    isCollidedVertically: boolean;
+    jumpTicks: number;
+    jumpQueued: boolean;
+    sneakCollision: boolean;
+    attributes: any;
+    isUsingItem: boolean;
+    isUsingMainHand: boolean;
+    isUsingOffHand: boolean;
+    jumpBoost: number;
+    speed: number;
+    slowness: number;
+    dolphinsGrace: number;
+    slowFalling: number;
+    levitation: number;
+    depthStrider: number;
+    effects: Effect[];
+    pose: PlayerPoses;
+    constructor(ctx: IPhysics, height: number, halfWidth: number, position: Vec3, velocity: Vec3, onGround: boolean, controlState: ControlStateHandler, yaw: number, pitch: number);
+    static CREATE_FROM_BOT(ctx: IPhysics, bot: Bot): EntityState;
+    static CREATE_FROM_ENTITY(ctx: IPhysics, entity: Entity): EntityState;
+    static CREATE_FROM_PLAYER_STATE(ctx: IPhysics, state: PlayerState): EntityState;
+    /**
+     * Slightly different from the other two, use a pre-built object (assuming cloned) material.
+     * @param ctx Physics instance.
+     * @param raw CONSUMEABLE, build this with clones.
+     * @returns PhysicsState
+     */
+    static CREATE_RAW(ctx: IPhysics, raw: EntityStateBuilder): EntityState;
+    updateFromBot(bot: Bot): EntityState;
+    updateFromEntity(entity: Entity): this;
+    updateFromRaw(other: EntityStateBuilder): this;
+    applyToBot(bot: Bot): this;
+    /**
+     * No idea when you'd use this.
+     */
+    applyToEntity(entity: Entity): this;
+    clone(): EntityState;
+    merge(other: EntityState): this;
+    clearControlStates(): EntityState;
+    /**
+     * needs to be updated.
+     * @returns AABB
+     */
+    getAABB(): AABB;
+    getUnderlyingBlockBBs(world: any): AABB[];
+    getSurroundingBBs(world: any): AABB[];
+}

package/lib/physics/states/entityState.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityState = void 0;
+const mineflayer_util_plugin_1 = require("@nxg-org/mineflayer-util-plugin");
+const physicsUtils_1 = require("../../util/physicsUtils");
+const vec3_1 = require("vec3");
+const playerControls_1 = require("../player/playerControls");
+const poses_1 = require("./poses");
+const prismarine_nbt_1 = __importDefault(require("prismarine-nbt"));
+const emptyVec = new vec3_1.Vec3(0, 0, 0);
+class EntityState {
+    // public effects: Effect[];
+    // public statusEffectNames;
+    constructor(ctx, height, halfWidth, position, velocity, onGround, controlState, yaw, pitch) {
+        this.ctx = ctx;
+        this.height = height;
+        this.halfWidth = halfWidth;
+        this.position = position;
+        this.velocity = velocity;
+        this.onGround = onGround;
+        this.controlState = controlState;
+        this.yaw = yaw;
+        this.pitch = pitch;
+        // may keep this, may not. Who knows?
+        this.age = 0;
+        this.isInWater = false;
+        this.isInLava = false;
+        this.isInWeb = false;
+        this.isCollidedHorizontally = false;
+        this.isCollidedVertically = false;
+        this.sneakCollision = false; //TODO
+        //not sure what to do here, ngl.
+        this.jumpTicks = 0;
+        this.jumpQueued = false;
+        // Input only (not modified)
+        this.attributes = {}; //TODO
+        this.isUsingItem = false;
+        this.isUsingMainHand = false;
+        this.isUsingOffHand = false;
+        // effects
+        this.effects = [];
+        this.jumpBoost = 0;
+        this.speed = 0;
+        this.slowness = 0;
+        this.dolphinsGrace = 0;
+        this.slowFalling = 0;
+        this.levitation = 0;
+        this.depthStrider = 0;
+        this.pose = poses_1.PlayerPoses.STANDING;
+    }
+    static CREATE_FROM_BOT(ctx, bot) {
+        return new EntityState(ctx, bot.entity.height, bot.entity.width / 2, bot.entity.position.clone(), bot.entity.velocity.clone(), bot.entity.onGround, playerControls_1.ControlStateHandler.COPY_BOT(bot), bot.entity.yaw, bot.entity.pitch).updateFromBot(bot);
+    }
+    static CREATE_FROM_ENTITY(ctx, entity) {
+        return new EntityState(ctx, entity.height, entity.width / 2, entity.position.clone(), entity.velocity.clone(), entity.onGround, playerControls_1.ControlStateHandler.DEFAULT(), entity.yaw, entity.pitch).updateFromEntity(entity);
+    }
+    static CREATE_FROM_PLAYER_STATE(ctx, state) {
+        return new EntityState(ctx, state.height, state.halfWidth, state.position.clone(), state.velocity.clone(), state.onGround, state.controlState.clone(), state.yaw, state.pitch).updateFromRaw(state);
+    }
+    /**
+     * Slightly different from the other two, use a pre-built object (assuming cloned) material.
+     * @param ctx Physics instance.
+     * @param raw CONSUMEABLE, build this with clones.
+     * @returns PhysicsState
+     */
+    static CREATE_RAW(ctx, raw) {
+        return new EntityState(ctx, raw.height, raw.halfWidth, raw.position, raw.velocity, raw.onGround, raw.controlState, raw.yaw, raw.pitch);
+    }
+    updateFromBot(bot) {
+        var _a, _b;
+        this.controlState = playerControls_1.ControlStateHandler.COPY_BOT(bot);
+        this.onGround = this.onGround;
+        this.isUsingItem = (0, physicsUtils_1.isEntityUsingItem)(bot.entity);
+        this.attributes = bot.entity.attributes;
+        this.effects = bot.entity.effects;
+        this.jumpBoost = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.JUMP_BOOST, this.effects);
+        this.speed = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.SPEED, this.effects);
+        this.slowness = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.SLOWNESS, this.effects);
+        this.dolphinsGrace = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.DOLPHINS_GRACE, this.effects);
+        this.slowFalling = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.SLOW_FALLING, this.effects);
+        this.levitation = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.LEVITATION, this.effects);
+        const boots = bot.entity.equipment[5];
+        if (boots && boots.nbt) {
+            const simplifiedNbt = prismarine_nbt_1.default.simplify(boots.nbt);
+            const enchantments = (_b = (_a = simplifiedNbt.Enchantments) !== null && _a !== void 0 ? _a : simplifiedNbt.ench) !== null && _b !== void 0 ? _b : [];
+            this.depthStrider = this.ctx.getEnchantmentLevelCustom(physicsUtils_1.CheapEnchantments.DEPTH_STRIDER, enchantments);
+        }
+        else {
+            this.depthStrider = 0;
+        }
+        return this;
+    }
+    updateFromEntity(entity) {
+        var _a, _b;
+        this.position = entity.position.clone();
+        this.velocity = entity.velocity.clone();
+        this.onGround = entity.onGround;
+        this.isInWater = entity.isInWater;
+        this.isInLava = entity.isInLava;
+        this.isInWeb = entity.isInWeb;
+        this.isCollidedHorizontally = entity.isCollidedHorizontally;
+        this.isCollidedVertically = entity.isCollidedVertically;
+        this.sneakCollision = false; //TODO
+        //not sure what to do here, ngl.
+        this.jumpTicks = 0;
+        this.jumpQueued = false;
+        // Input only (not modified)
+        this.attributes = entity.attributes;
+        this.yaw = entity.yaw;
+        this.pitch = entity.pitch;
+        this.controlState = playerControls_1.ControlStateHandler.DEFAULT();
+        this.isUsingItem = (0, physicsUtils_1.isEntityUsingItem)(entity);
+        this.isUsingMainHand = !(0, physicsUtils_1.whichHandIsEntityUsingBoolean)(entity) && this.isUsingItem;
+        this.isUsingOffHand = (0, physicsUtils_1.whichHandIsEntityUsingBoolean)(entity) && this.isUsingItem;
+        // effects
+        this.effects = entity.effects;
+        this.jumpBoost = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.JUMP_BOOST, this.effects);
+        this.speed = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.SPEED, this.effects);
+        this.slowness = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.SLOWNESS, this.effects);
+        this.dolphinsGrace = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.DOLPHINS_GRACE, this.effects);
+        this.slowFalling = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.SLOW_FALLING, this.effects);
+        this.levitation = this.ctx.getEffectLevelCustom(physicsUtils_1.CheapEffects.LEVITATION, this.effects);
+        // armour enchantments
+        //const boots = bot.inventory.slots[8];
+        const boots = entity.equipment[5];
+        if (boots && boots.nbt) {
+            const simplifiedNbt = prismarine_nbt_1.default.simplify(boots.nbt);
+            const enchantments = (_b = (_a = simplifiedNbt.Enchantments) !== null && _a !== void 0 ? _a : simplifiedNbt.ench) !== null && _b !== void 0 ? _b : [];
+            this.depthStrider = this.ctx.getEnchantmentLevelCustom(physicsUtils_1.CheapEnchantments.DEPTH_STRIDER, enchantments);
+        }
+        else {
+            this.depthStrider = 0;
+        }
+        this.pose = poses_1.PlayerPoses.STANDING;
+        return this;
+    }
+    updateFromRaw(other) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        this.onGround = (_a = other.onGround) !== null && _a !== void 0 ? _a : this.onGround;
+        this.sneakCollision = (_b = other.sneakCollision) !== null && _b !== void 0 ? _b : this.sneakCollision;
+        this.isUsingItem = (_c = other.isUsingItem) !== null && _c !== void 0 ? _c : this.isUsingItem;
+        this.jumpBoost = (_d = other.jumpBoost) !== null && _d !== void 0 ? _d : this.jumpBoost;
+        this.speed = (_e = other.speed) !== null && _e !== void 0 ? _e : this.speed;
+        this.slowness = (_f = other.slowness) !== null && _f !== void 0 ? _f : this.slowness;
+        this.dolphinsGrace = (_g = other.dolphinsGrace) !== null && _g !== void 0 ? _g : this.dolphinsGrace;
+        this.slowFalling = (_h = other.slowFalling) !== null && _h !== void 0 ? _h : this.slowFalling;
+        this.levitation = (_j = other.levitation) !== null && _j !== void 0 ? _j : this.levitation;
+        this.depthStrider = (_k = other.depthStrider) !== null && _k !== void 0 ? _k : this.depthStrider;
+        this.effects = (_l = other.effects) !== null && _l !== void 0 ? _l : this.effects;
+        return this;
+    }
+    applyToBot(bot) {
+        bot.entity.position = this.position;
+        bot.entity.velocity = this.velocity;
+        bot.entity.onGround = this.onGround;
+        bot.entity.yaw = this.yaw;
+        bot.entity.pitch = this.pitch;
+        bot.controlState = this.controlState;
+        return this;
+    }
+    /**
+     * No idea when you'd use this.
+     */
+    applyToEntity(entity) {
+        entity.position = this.position;
+        entity.velocity = this.velocity;
+        entity.onGround = this.onGround;
+        entity.yaw = this.yaw;
+        entity.pitch = this.pitch;
+        return this;
+    }
+    clone() {
+        const other = new EntityState(this.ctx, this.height, this.halfWidth, this.position.clone(), this.velocity.clone(), this.onGround, this.controlState.clone(), this.yaw, this.pitch);
+        other.age = this.age;
+        other.isCollidedHorizontally = this.isCollidedHorizontally;
+        other.isCollidedVertically = this.isCollidedVertically;
+        other.isInWater = this.isInWater;
+        other.isInLava = this.isInLava;
+        other.isInWeb = this.isInWeb;
+        other.jumpTicks = this.jumpTicks;
+        other.jumpQueued = this.jumpQueued;
+        other.sneakCollision = this.sneakCollision;
+        other.attributes = this.attributes;
+        other.isUsingItem = this.isUsingItem;
+        other.isUsingMainHand = this.isUsingMainHand;
+        other.isUsingOffHand = this.isUsingOffHand;
+        other.jumpBoost = this.jumpBoost;
+        other.speed = this.speed;
+        other.slowness = this.slowness;
+        other.dolphinsGrace = this.dolphinsGrace;
+        other.slowFalling = this.slowFalling;
+        other.levitation = this.levitation;
+        other.depthStrider = this.depthStrider;
+        other.effects = this.effects;
+        other.pose = this.pose;
+        return other;
+    }
+    merge(other) {
+        this.age = other.age;
+        this.position = other.position.clone();
+        this.velocity = other.velocity.clone();
+        this.onGround = other.onGround;
+        this.isCollidedHorizontally = other.isCollidedHorizontally;
+        this.isCollidedVertically = other.isCollidedVertically;
+        this.isInWater = other.isInWater;
+        this.isInLava = other.isInLava;
+        this.isInWeb = other.isInWeb;
+        this.jumpTicks = other.jumpTicks;
+        this.jumpQueued = other.jumpQueued;
+        this.sneakCollision = other.sneakCollision;
+        this.attributes = other.attributes;
+        this.isUsingItem = other.isUsingItem;
+        this.isUsingMainHand = other.isUsingMainHand;
+        this.isUsingOffHand = other.isUsingOffHand;
+        this.jumpBoost = other.jumpBoost;
+        this.speed = other.speed;
+        this.slowness = other.slowness;
+        this.dolphinsGrace = other.dolphinsGrace;
+        this.slowFalling = other.slowFalling;
+        this.levitation = other.levitation;
+        this.depthStrider = other.depthStrider;
+        this.effects = other.effects;
+        this.pose = other.pose;
+        return this;
+    }
+    clearControlStates() {
+        this.controlState = playerControls_1.ControlStateHandler.DEFAULT();
+        return this;
+    }
+    /**
+     * needs to be updated.
+     * @returns AABB
+     */
+    getAABB() {
+        const w = this.halfWidth;
+        return new mineflayer_util_plugin_1.AABB(this.position.x - w, this.position.y, this.position.z - w, this.position.x + w, this.position.y + this.height, this.position.z + w);
+    }
+    getUnderlyingBlockBBs(world /*prismarine-world*/) {
+        const queryBB = this.getAABB();
+        return this.ctx.getUnderlyingBlockBBs(queryBB, world);
+    }
+    getSurroundingBBs(world /*prismarine-world*/) {
+        const queryBB = this.getAABB();
+        return this.ctx.getSurroundingBBs(queryBB, world);
+    }
+}
+exports.EntityState = EntityState;

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

@@ -0,0 +1,3 @@
+export * from "./entityState";
+export * from "./playerState";
+export * from "./poses";

package/lib/physics/states/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entityState"), exports);
+__exportStar(require("./playerState"), exports);
+__exportStar(require("./poses"), exports);

package/lib/physics/states/playerState.d.ts

@@ -0,0 +1,74 @@
+import { Bot, Effect } from "mineflayer";
+import { AABB } from "@nxg-org/mineflayer-util-plugin";
+import { Vec3 } from "vec3";
+import { ControlStateHandler } from "../player/playerControls";
+import { EntityStateBuilder } from "./entityState";
+import { IPhysics } from "../engines/IPhysics";
+export declare class EntityDimensions {
+    readonly width: number;
+    readonly height: number;
+    readonly fixed: boolean;
+    constructor(width: number, height: number, fixed: boolean);
+    static scalable(f: number, f2: number): EntityDimensions;
+    static fixed(f: number, f2: number): EntityDimensions;
+    makeBoundingBox(vec3: Vec3): AABB;
+    makeBoundingBoxCoords(d: number, d2: number, d3: number): AABB;
+    scale(f: number): EntityDimensions;
+    scaleRaw(f: number, f2: number): EntityDimensions;
+    toString(): String;
+}
+/**
+ * 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 PlayerState implements EntityStateBuilder {
+    readonly bot: Bot;
+    height: number;
+    halfWidth: number;
+    position: Vec3;
+    velocity: Vec3;
+    onGround: boolean;
+    isInWater: boolean;
+    isInLava: boolean;
+    isInWeb: boolean;
+    isCollidedHorizontally: boolean;
+    isCollidedVertically: boolean;
+    jumpTicks: number;
+    jumpQueued: boolean;
+    sneakCollision: boolean;
+    attributes: any;
+    yaw: number;
+    pitch: number;
+    controlState: ControlStateHandler;
+    isUsingItem: boolean;
+    isUsingMainHand: boolean;
+    isUsingOffHand: boolean;
+    jumpBoost: number;
+    speed: number;
+    slowness: number;
+    dolphinsGrace: number;
+    slowFalling: number;
+    levitation: number;
+    depthStrider: number;
+    effects: Effect[];
+    statusEffectNames: {
+        jumpBoostEffectName: string;
+        speedEffectName: string;
+        slownessEffectName: string;
+        dolphinsGraceEffectName: string;
+        slowFallingEffectName: string;
+        levitationEffectName: string;
+    };
+    readonly ctx: IPhysics;
+    private readonly supportFeature;
+    constructor(ctx: IPhysics, bot: Bot, control?: ControlStateHandler);
+    update(bot: Bot, control?: ControlStateHandler): PlayerState;
+    apply(bot: Bot): void;
+    clone(): PlayerState;
+    merge(other: PlayerState): this;
+    clearControlStates(): PlayerState;
+    getAABB(): AABB;
+    getUnderlyingBlockBBs(world: any): AABB[];
+    getSurroundingBBs(world: any): AABB[];
+}