@nxg-org/mineflayer-util-plugin 1.0.0

package/lib/worldRelated/raycastIterator.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaycastIterator = exports.BlockFace = void 0;
+const vec3_1 = require("vec3");
+var BlockFace;
+(function (BlockFace) {
+    BlockFace[BlockFace["UNKNOWN"] = -999] = "UNKNOWN";
+    BlockFace[BlockFace["BOTTOM"] = 0] = "BOTTOM";
+    BlockFace[BlockFace["TOP"] = 1] = "TOP";
+    BlockFace[BlockFace["NORTH"] = 2] = "NORTH";
+    BlockFace[BlockFace["SOUTH"] = 3] = "SOUTH";
+    BlockFace[BlockFace["WEST"] = 4] = "WEST";
+    BlockFace[BlockFace["EAST"] = 5] = "EAST";
+})(BlockFace = exports.BlockFace || (exports.BlockFace = {}));
+class RaycastIterator {
+    constructor(pos, dir, maxDistance) {
+        this.block = {
+            x: Math.floor(pos.x),
+            y: Math.floor(pos.y),
+            z: Math.floor(pos.z),
+            face: BlockFace.UNKNOWN,
+        };
+        this.blockVec = new vec3_1.Vec3(Math.floor(pos.x), Math.floor(pos.y), Math.floor(pos.z));
+        this.pos = pos;
+        this.dir = dir;
+        this.invDirX = dir.x === 0 ? Number.MAX_VALUE : 1 / dir.x;
+        this.invDirY = dir.y === 0 ? Number.MAX_VALUE : 1 / dir.y;
+        this.invDirZ = dir.z === 0 ? Number.MAX_VALUE : 1 / dir.z;
+        this.stepX = Math.sign(dir.x);
+        this.stepY = Math.sign(dir.y);
+        this.stepZ = Math.sign(dir.z);
+        this.tDeltaX = dir.x === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.x);
+        this.tDeltaY = dir.y === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.y);
+        this.tDeltaZ = dir.z === 0 ? Number.MAX_VALUE : Math.abs(1 / dir.z);
+        this.tMaxX = dir.x === 0 ? Number.MAX_VALUE : Math.abs((this.block.x + (dir.x > 0 ? 1 : 0) - pos.x) / dir.x);
+        this.tMaxY = dir.y === 0 ? Number.MAX_VALUE : Math.abs((this.block.y + (dir.y > 0 ? 1 : 0) - pos.y) / dir.y);
+        this.tMaxZ = dir.z === 0 ? Number.MAX_VALUE : Math.abs((this.block.z + (dir.z > 0 ? 1 : 0) - pos.z) / dir.z);
+        this.maxDistance = maxDistance;
+    }
+    // Returns null if none of the shapes is intersected, otherwise returns intersect pos and face
+    // shapes are translated by offset
+    //[x0: number,y0: number,z0: number,x1:number,y1:number,z1:number][]
+    intersect(shapes, offset) {
+        // Shapes is an array of shapes, each in the form of: [x0, y0, z0, x1, y1, z1]
+        let t = Number.MAX_VALUE;
+        let f = BlockFace.UNKNOWN;
+        const p = this.pos.minus(offset);
+        for (const shape of shapes) {
+            let tmin = (shape[this.invDirX > 0 ? 0 : 3] - p.x) * this.invDirX;
+            let tmax = (shape[this.invDirX > 0 ? 3 : 0] - p.x) * this.invDirX;
+            const tymin = (shape[this.invDirY > 0 ? 1 : 4] - p.y) * this.invDirY;
+            const tymax = (shape[this.invDirY > 0 ? 4 : 1] - p.y) * this.invDirY;
+            let face = this.stepX > 0 ? BlockFace.WEST : BlockFace.EAST;
+            if (tmin > tymax || tymin > tmax)
+                continue;
+            if (tymin > tmin) {
+                tmin = tymin;
+                face = this.stepY > 0 ? BlockFace.BOTTOM : BlockFace.TOP;
+            }
+            if (tymax < tmax)
+                tmax = tymax;
+            const tzmin = (shape[this.invDirZ > 0 ? 2 : 5] - p.z) * this.invDirZ;
+            const tzmax = (shape[this.invDirZ > 0 ? 5 : 2] - p.z) * this.invDirZ;
+            if (tmin > tzmax || tzmin > tmax)
+                continue;
+            if (tzmin > tmin) {
+                tmin = tzmin;
+                face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+            if (tzmax < tmax)
+                tmax = tzmax;
+            if (tmin < t) {
+                t = tmin;
+                f = face;
+            }
+        }
+        if (t === Number.MAX_VALUE)
+            return null;
+        return { pos: this.pos.plus(this.dir.scaled(t)), face: f };
+    }
+    next() {
+        if (Math.min(Math.min(this.tMaxX, this.tMaxY), this.tMaxZ) > this.maxDistance) {
+            return null;
+        }
+        if (this.tMaxX < this.tMaxY) {
+            if (this.tMaxX < this.tMaxZ) {
+                this.block.x += this.stepX;
+                this.tMaxX += this.tDeltaX;
+                this.block.face = this.stepX > 0 ? BlockFace.WEST : BlockFace.EAST;
+            }
+            else {
+                this.block.z += this.stepZ;
+                this.tMaxZ += this.tDeltaZ;
+                this.block.face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+        }
+        else {
+            if (this.tMaxY < this.tMaxZ) {
+                this.block.y += this.stepY;
+                this.tMaxY += this.tDeltaY;
+                this.block.face = this.stepY > 0 ? BlockFace.BOTTOM : BlockFace.TOP;
+            }
+            else {
+                this.block.z += this.stepZ;
+                this.tMaxZ += this.tDeltaZ;
+                this.block.face = this.stepZ > 0 ? BlockFace.NORTH : BlockFace.SOUTH;
+            }
+        }
+        if (isNaN(this.block.x) || isNaN(this.block.y) || isNaN(this.block.z))
+            return null;
+        return this.block;
+    }
+}
+exports.RaycastIterator = RaycastIterator;

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@nxg-org/mineflayer-util-plugin",
+    "version": "1.0.0",
+    "description": "mineflayer utils for NextGEN mineflayer plugins.",
+    "keywords": [
+        "mineflayer",
+        "mineflayer-util"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nxg-org/mineflayer-util-plugin.git"
+    },
+    "license": "GPL-3.0",
+    "author": "generel_schwerz",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "scripts": {
+        "build": "npx tsc",
+        "prepublish": "npm run build"
+    },
+    "dependencies": {
+        "minecraft-data": "^2.97.0",
+        "mineflayer": "^3.11.2",
+        "mineflayer-pathfinder": "^1.8.0",
+        "prismarine-block": "^1.10.3",
+        "prismarine-item": "^1.11.1",
+        "vec3": "^0.1.7"
+    },
+    "devDependencies": {
+        "@types/node": "^16.11.11",
+        "typescript": "^4.5.2"
+    }
+}

package/src/WorldFunctions.ts

@@ -0,0 +1,19 @@
+import type { Bot } from "mineflayer";
+import type { Block } from "prismarine-block";
+import { AABB } from "./calcs/aabb";
+import type { Vec3 } from "vec3";
+
+export class WorldFunctions {
+    constructor (private bot: Bot) {}
+
+
+    getBlockAABB(block: Block, height: number = 1) {
+        const {x, y, z} = block.position
+        return new AABB(x, y, z, x + 1, y + height, z + 1)
+    }
+
+    getBlockPosAABB(block: Vec3, height: number = 1) {
+        const {x, y, z} = block.floored()
+        return new AABB(x, y, z, x + 1, y + height, z + 1)
+    }
+}

package/src/calcs/aabb.ts

@@ -0,0 +1,218 @@
+import { Vec3 } from "vec3";
+
+export class AABB {
+    public minX: number;
+    public minY: number;
+    public minZ: number;
+    public maxX: number;
+    public maxY: number;
+    public maxZ: number;
+
+    constructor(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number) {
+        this.minX = x0;
+        this.minY = y0;
+        this.minZ = z0;
+        this.maxX = x1;
+        this.maxY = y1;
+        this.maxZ = z1;
+    }
+
+    static fromVecs(min: Vec3, max: Vec3) {
+        return new AABB(min.x, min.y, min.z, max.x, max.y, max.z);
+    }
+
+    set(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number) {
+        this.minX = x0;
+        this.minY = y0;
+        this.minZ = z0;
+        this.maxX = x1;
+        this.maxY = y1;
+        this.maxZ = z1;
+    }
+
+    clone() {
+        return new AABB(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
+    }
+
+    toArray() {
+        return [this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ];
+    }
+
+    toMinAndMaxArrays() {
+        return { 0: [this.minX, this.minY, this.minZ], 1: [this.maxX, this.maxY, this.maxZ] };
+    }
+
+    toVecs() {
+        return { 0: new Vec3(this.minX, this.minY, this.minZ), 1: new Vec3(this.maxX, this.maxY, this.maxZ) };
+    }
+
+    floor() {
+        this.minX = Math.floor(this.minX);
+        this.minY = Math.floor(this.minY);
+        this.minZ = Math.floor(this.minZ);
+        this.maxX = Math.floor(this.maxX);
+        this.maxY = Math.floor(this.maxY);
+        this.maxZ = Math.floor(this.maxZ);
+    }
+
+    extend(dx: number, dy: number, dz: number) {
+        if (dx < 0) this.minX += dx;
+        else this.maxX += dx;
+
+        if (dy < 0) this.minY += dy;
+        else this.maxY += dy;
+
+        if (dz < 0) this.minZ += dz;
+        else this.maxZ += dz;
+
+        return this;
+    }
+
+    contract(x: number, y: number, z: number) {
+        this.minX += x;
+        this.minY += y;
+        this.minZ += z;
+        this.maxX -= x;
+        this.maxY -= y;
+        this.maxZ -= z;
+        return this;
+    }
+
+    expand(x: number, y: number, z: number) {
+        this.minX -= x;
+        this.minY -= y;
+        this.minZ -= z;
+        this.maxX += x;
+        this.maxY += y;
+        this.maxZ += z;
+        return this;
+    }
+
+    offset(x: number, y: number, z: number) {
+        this.minX += x;
+        this.minY += y;
+        this.minZ += z;
+        this.maxX += x;
+        this.maxY += y;
+        this.maxZ += z;
+        return this;
+    }
+
+    computeOffsetX(other: AABB, offsetX: number) {
+        if (other.maxY > this.minY && other.minY < this.maxY && other.maxZ > this.minZ && other.minZ < this.maxZ) {
+            if (offsetX > 0.0 && other.maxX <= this.minX) {
+                offsetX = Math.min(this.minX - other.maxX, offsetX);
+            } else if (offsetX < 0.0 && other.minX >= this.maxX) {
+                offsetX = Math.max(this.maxX - other.minX, offsetX);
+            }
+        }
+        return offsetX;
+    }
+
+    computeOffsetY(other: AABB, offsetY: number) {
+        if (other.maxX > this.minX && other.minX < this.maxX && other.maxZ > this.minZ && other.minZ < this.maxZ) {
+            if (offsetY > 0.0 && other.maxY <= this.minY) {
+                offsetY = Math.min(this.minY - other.maxY, offsetY);
+            } else if (offsetY < 0.0 && other.minY >= this.maxY) {
+                offsetY = Math.max(this.maxY - other.minY, offsetY);
+            }
+        }
+        return offsetY;
+    }
+
+    computeOffsetZ(other: AABB, offsetZ: number) {
+        if (other.maxX > this.minX && other.minX < this.maxX && other.maxY > this.minY && other.minY < this.maxY) {
+            if (offsetZ > 0.0 && other.maxZ <= this.minZ) {
+                offsetZ = Math.min(this.minZ - other.maxZ, offsetZ);
+            } else if (offsetZ < 0.0 && other.minZ >= this.maxZ) {
+                offsetZ = Math.max(this.maxZ - other.minZ, offsetZ);
+            }
+        }
+        return offsetZ;
+    }
+
+    intersects(other: AABB) {
+        return (
+            this.minX < other.maxX &&
+            this.maxX > other.minX &&
+            this.minY < other.maxY &&
+            this.maxY > other.minY &&
+            this.minZ < other.maxZ &&
+            this.maxZ > other.minZ
+        );
+    }
+
+    intersectsRay(origin: Vec3, direction: Vec3) {
+        const d = this.distanceFromRay(origin, direction);
+        if (d === Infinity) {
+            return null;
+        } else {
+            return new Vec3(origin.x + direction.x * d, origin.y + direction.y * d, origin.z + direction.z * d);
+        }
+    }
+
+    distanceFromRay(origin: Vec3, direction: Vec3) {
+        const ro = origin.toArray();
+        const rd = direction.normalize().toArray();
+        const aabb = this.toMinAndMaxArrays();
+        const dims = ro.length; // will change later.
+        let lo = -Infinity;
+        let hi = +Infinity;
+        // let test = origin.clone()
+
+        for (let i = 0; i < dims; i++) {
+            let dimLo = (aabb[0][i] - ro[i]) / rd[i];
+            let dimHi = (aabb[1][i] - ro[i]) / rd[i];
+
+            if (dimLo > dimHi) {
+                let tmp = dimLo;
+                dimLo = dimHi;
+                dimHi = tmp;
+            }
+
+            // let num;
+            // switch (i) {
+            //     case 0:
+            //         num = "x"
+            //         break;
+            //     case 1:
+            //         num = "y"
+            //         break;
+            //     case 2:
+            //         num = "z"
+            //         break;
+            // }
+            // console.log(num, aabb[0][i], aabb[1][i], ro[i], "highest overall:", lo, hi )
+            if (dimHi < lo || dimLo > hi) {
+                console.log("fuck", dimHi < lo, dimLo > hi);
+                return Infinity;
+            }
+
+            if (dimLo > lo) lo = dimLo;
+            if (dimHi < hi) hi = dimHi;
+        }
+
+        return lo > hi ? Infinity : lo;
+    }
+
+    equals(other: AABB): boolean {
+        return (
+            this.minX === other.minX &&
+            this.minY === other.minY &&
+            this.minZ === other.minZ &&
+            this.maxX === other.maxX &&
+            this.maxY === other.maxY &&
+            this.maxZ === other.maxZ
+        );
+    }
+
+    distanceTo(pos: Vec3, heightOffset: number = 0): number {
+        const { x, y, z } = pos.offset(0, heightOffset, 0);
+        let dx = Math.max(this.minX - x, 0, x - this.maxX);
+        let dy = Math.max(this.minY - y, 0, y - this.maxY);
+        let dz = Math.max(this.minZ - z, 0, z - this.maxZ);
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+}
+
+export default AABB;

package/src/commonSense.ts

@@ -0,0 +1,189 @@
+import type { Bot, EquipmentDestination } from "mineflayer";
+import { Vec3 } from "vec3";
+import { promisify } from "util";
+import type { Block } from "prismarine-block";
+const sleep = promisify(setTimeout);
+
+export class CommonSense {
+    public autoRespond: boolean = false;
+    public isFalling: boolean = false;
+    public isOnFire: boolean = false;
+    public checkForFalling: boolean = true;
+    public checkForFire: boolean = true;
+    public useOffHand: boolean = true;
+    public requipLastItem: boolean = false;
+    public puttingOutFire: boolean = false;
+    public MLGing: boolean = false;
+    constructor(public bot: Bot) {
+        this.bot.on("physicsTick", this.isFallingCheckEasy.bind(this));
+        this.bot._client.on("entity_metadata", this.onMetadataFireCheck.bind(this));
+        this.bot._client.on("entity_status", this.onStatusFireCheck.bind(this));
+        // this.bot.on("physicsTick", this.onPhysicsTickFireCheck.bind(this));
+        //TODO: Move this to bot movement.
+    }
+
+    // async onPhysicsTickFireCheck() {
+    //     if ((this.bot.entity.metadata[0] as any) === 1) {
+    //         this.isOnFire = true;
+    //         while (!this.bot.entity.onGround) await sleep(0);
+    //         if (!this.puttingOutFire && this.autoRespond) this.putOutFire();
+    //     } else {
+    //         this.isOnFire = false
+    //     }
+    // }
+
+    async onMetadataFireCheck(packet: any) {
+        if (!this.checkForFire) return;
+        if (!packet.entityId) return;
+        const entity = this.bot.entities[packet.entityId];
+        if (!entity || entity !== this.bot.entity) return;
+        // if ((entity.metadata[0] as any).value !== 1) {
+        const wantedKey = (packet.metadata as any[]).findIndex((md) => md.key === 0);
+        if (wantedKey === -1) return;
+        if (packet.metadata[wantedKey]?.value !== 1) {
+            this.isOnFire = false;
+            return;
+        }
+        // }
+
+        this.isOnFire = true;
+        while (!this.bot.entity.onGround) await this.bot.waitForTicks(1);
+        if (!this.puttingOutFire && this.autoRespond) this.putOutFire();
+    }
+
+    async onStatusFireCheck(packet: any) {
+        if (!this.checkForFire) return;
+        if (!packet.entityId) return;
+        const entity = this.bot.entities[packet.entityId];
+        if (!entity || entity !== this.bot.entity) return;
+        if (!packet.entityStatus || packet.entityStatus !== 37) {
+            this.isOnFire = false;
+            return;
+        }
+
+        this.isOnFire = true;
+        while (!this.bot.entity.onGround) await sleep(0);
+        if (!this.puttingOutFire && this.autoRespond) this.putOutFire();
+    }
+
+    async putOutFire() {
+        if (this.puttingOutFire) return true;
+        this.puttingOutFire = true;
+        const water = this.bot.util.inv.getAllItemsExceptCurrent("off-hand").find((item) => item?.name.includes("water_bucket"));
+        const holdingItem = this.bot.util.inv.getHandWithItem(this.useOffHand)?.name.includes("water_bucket");
+        if (!water && !holdingItem) {
+            this.puttingOutFire = false;
+            return false;
+        } else if (!holdingItem && water) await this.bot.util.inv.customEquip(water, "off-hand");
+
+        if (this.bot.util.inv.getHandWithItem(this.useOffHand)?.name.includes("water_bucket")) {
+            const nearbyBlock = this.bot.findBlock({ matching: (block) => block?.name === "fire", maxDistance: 2 });
+
+            if (nearbyBlock) {
+                await this.bot.dig(nearbyBlock, true);
+                await this.bot.util.move.forceLookAt(nearbyBlock.position.offset(0, -1, 0));
+            } else {
+                await this.bot.util.move.forceLook(this.bot.entity.yaw, -90);
+            }
+            // while (!this.bot.entity.isCollidedVertically) await this.bot.waitForTicks(1);
+            this.bot.activateItem(this.useOffHand);
+
+            await this.pickUpWater(nearbyBlock);
+            this.puttingOutFire = false;
+            return true;
+        } else {
+            this.puttingOutFire = false;
+            return false;
+        }
+    }
+
+    async pickUpWater(nearbyBlock: Block | null = null, maxDistance: number = 2, immediate: boolean = false) {
+        if (!immediate) await this.bot.waitForTicks(3);
+        const block = this.bot.findBlock({
+            point: nearbyBlock?.position ?? this.bot.entity.position,
+            matching: (block) => (block.type === 8 || block.type === 9) && block.metadata === 0,
+            //@ts-expect-error
+            useExtraInfo: (block: Block) => {
+                return this.bot.util.world.getBlockAABB(block).distanceTo(this.bot.entity.position, 1.62) < 4;
+            },
+            maxDistance: maxDistance,
+        });
+        if (block) {
+            this.bot.util.move.forceLookAt(block.position.offset(0.5, 0.5, 0.5), true);
+            this.bot.activateItem(this.useOffHand);
+        } else {
+            console.log("didn't get block. fuck.");
+        }
+    }
+    async isFallingCheckEasy() {
+        if (!this.checkForFalling) return;
+        if (this.bot.entity.velocity.y >= -0.6) {
+            this.isFalling = false;
+            return;
+        }
+        this.isFalling = true;
+        if (!this.MLGing && this.autoRespond) {
+            await this.waterBucket();
+        }
+    }
+
+    private findBlockForWaterPlacement() {
+        const pos = this.bot.entity.position.offset(this.bot.entity.velocity.x, 0, this.bot.entity.velocity.z);
+        const aabb = this.bot.util.entity.getEntityAABB({
+            position: pos,
+            height: this.bot.entity.height,
+            width: 0.3,
+        });
+        const spacing = { x0: aabb.minX, z0: aabb.minZ, x1: aabb.maxX, z1: aabb.maxZ };
+        const floored = { x0: Math.floor(spacing.x0), z0: Math.floor(spacing.z0), x1: Math.floor(spacing.x1), z1: Math.floor(spacing.z1) };
+        let blocks: Block[] = [];
+        const posY = this.bot.entity.position.clone().floored().y;
+        loop1: for (let i = floored.x0; i <= floored.x1; i++) {
+            loop2: for (let j = floored.z0; j <= floored.z1; j++) {
+                loop3: for (let k = posY; k > 0; k--) {
+                    const block = this.bot.blockAt(new Vec3(i, k, j));
+                    if (!!block && block.type !== 0) {
+                        blocks.push(block);
+                        break loop3;
+                    }
+                }
+            }
+        }
+
+        const maxY = Math.max(...blocks.map((b) => b.position.y));
+        blocks = blocks.filter((b) => b.position.y === maxY);
+
+        const block = blocks.sort(
+            (a, b) => this.bot.util.world.getBlockAABB(b).distanceTo(pos) - this.bot.util.world.getBlockAABB(a).distanceTo(pos)
+        )[0];
+        // console.log(block.position, this.bot.entity.position, this.bot.entity.position.distanceTo(block.position).toFixed(2));
+        return block;
+    }
+
+    async waterBucket() {
+        if (this.MLGing) return true;
+        this.MLGing = true;
+        const water = this.bot.util.inv.getAllItemsExceptCurrent("off-hand").find((item) => item?.name.includes("water_bucket"));
+        const holdingItem = this.bot.util.inv.getHandWithItem(true)?.name.includes("water_bucket");
+        if (!water && !holdingItem) {
+            this.MLGing = false;
+            return false;
+        } else if (!holdingItem && water) await this.bot.util.inv.customEquip(water, "off-hand");
+
+        for (let i = 0; i < 120; i++) {
+            const landingBlock = this.findBlockForWaterPlacement();
+            if (landingBlock) {
+                await this.bot.util.move.forceLookAt(landingBlock.position.offset(0.5, 0.5, 0.5), true);
+            }
+
+            if (this.bot.entity.position.y <= (landingBlock?.position.y ?? 0) + 3) {
+                this.bot.activateItem(this.useOffHand);
+                break;
+            }
+            await this.bot.waitForTicks(1);
+        }
+        await this.pickUpWater(null, 2);
+        this.MLGing = false;
+        return true;
+    }
+}

package/src/customImplementations/inventory.ts

@@ -0,0 +1,90 @@
+import type { Bot, EquipmentDestination } from "mineflayer";
+import type { Item } from "prismarine-item";
+import assert from "assert";
+import { promisify } from "util";
+const sleep = promisify(setTimeout);
+
+const QUICK_BAR_COUNT = 9;
+const QUICK_BAR_START = 36;
+
+let nextQuickBarSlot = 0;
+
+//lazy. will fix this later.
+
+export class CustomInventoryFunctions {
+    armorSlots = {
+        head: 5,
+        torso: 6,
+        legs: 7,
+        feet: 8,
+    } as any;
+
+    constructor(private bot: Bot) {
+        if (!bot.supportFeature("doesntHaveOffHandSlot")) {
+            this.armorSlots["off-hand"] = 45;
+        }
+    }
+
+    async equip(item: Item, destination: EquipmentDestination) {
+        if (item == null || typeof item !== "object") {
+            throw new Error("Invalid item object in equip (item is null or typeof item is not object)");
+        }
+        if (!destination || destination === null) {
+            destination = "hand";
+        }
+        const sourceSlot = item.slot;
+        let destSlot = this.getDestSlot(destination);
+
+        if (sourceSlot === destSlot) {
+            // don't need to do anything
+            return;
+        }
+
+        if (destination !== "hand") {
+            await this.bot.moveSlotItem(sourceSlot, destSlot);
+            return;
+        }
+
+        if (
+            destSlot >= QUICK_BAR_START &&
+            destSlot < QUICK_BAR_START + QUICK_BAR_COUNT &&
+            sourceSlot >= QUICK_BAR_START &&
+            sourceSlot < QUICK_BAR_START + QUICK_BAR_COUNT
+        ) {
+            // all we have to do is change the quick bar selection
+            this.bot.setQuickBarSlot(sourceSlot - QUICK_BAR_START);
+            return;
+        }
+
+        // find an empty slot on the quick bar to put the source item in
+        destSlot = this.bot.inventory.firstEmptySlotRange(QUICK_BAR_START, QUICK_BAR_START + QUICK_BAR_COUNT);
+        if (destSlot == null) {
+            // LRU cache for the quick bar items
+            destSlot = QUICK_BAR_START + nextQuickBarSlot;
+            nextQuickBarSlot = (nextQuickBarSlot + 1) % QUICK_BAR_COUNT;
+        }
+        this.setQuickBarSlot(destSlot - QUICK_BAR_START);
+        await this.bot.moveSlotItem(sourceSlot, destSlot);
+    }
+
+    setQuickBarSlot(slot: number) {
+        assert.ok(slot >= 0);
+        assert.ok(slot < 9);
+        if (this.bot.quickBarSlot === slot) return;
+        this.bot.quickBarSlot = slot;
+        this.bot._client.write("held_item_slot", {
+            slotId: slot,
+        });
+        this.bot.updateHeldItem();
+    }
+
+    getDestSlot(destination: EquipmentDestination) {
+        if (destination === "hand") {
+            return QUICK_BAR_START + this.bot.quickBarSlot;
+        } else {
+            const destSlot = this.armorSlots[destination];
+            assert.ok(destSlot != null, `invalid destination: ${destination}`);
+            return destSlot;
+        }
+    }
+}