feat(mover): ✨ add basic movement commands

Forward, left, etc. Uses bot.controlState. But left and right does the opposite of expectations.
build: ⬆️ update deps
2021-01-18 15:13:53 +05:00 · 2021-01-18 01:54:05 +05:00 · 2021-01-18 01:47:32 +05:00 · 2021-01-18 01:24:47 +05:00 · 2021-01-17 23:59:39 +05:00 · 2021-01-17 18:32:05 +05:00
8 changed files with 494 additions and 196 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,8 @@
+{
+    "conventionalCommits.scopes": [
+        "command",
+        "mover",
+        "sleeper",
+        "informer"
+    ]
+}
--- a/lib/index.js
+++ b/lib/index.js
@@ -9,19 +9,22 @@ let cfg = {
 const mineflayer = require("mineflayer");
 // const { createGetAccessor } = require('typescript');

-const bot =
-    !isNaN(parseInt(process.argv[3])) && parseInt(process.argv[3]) > 1e2 ?
-        mineflayer.createBot({
-            host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost',  // Change this to the ip you want.
-            port: parseInt(process.argv[3]) || process.env.MINECRAFT_PORT || env.MINECRAFT_PORT // || 58471,
-        })
-        :
-        mineflayer.createBot({
-            host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost',  // Change this to the ip you want.
-            username: process.argv[3] || process.env.MINECRAFT_USER || env.MINECRAFT_USER,
-            password: process.argv[4] || process.env.MINECRAFT_PASS || env.MINECRAFT_PASS,
-            // port: process.argv[5] || process.env.MINECRAFT_PORT || 58471,
-        })
+const options = !isNaN(parseInt(process.argv[3])) && parseInt(process.argv[3]) > 1e2 ?
+    {
+        host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost',  // Change this to the ip you want.
+        port: parseInt(process.argv[3]) || process.env.MINECRAFT_PORT || env.MINECRAFT_PORT // || 58471,
+    }
+    :
+    {
+        host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost',  // Change this to the ip you want.
+        username: process.argv[3] || process.env.MINECRAFT_USER || env.MINECRAFT_USER,
+        password: process.argv[4] || process.env.MINECRAFT_PASS || env.MINECRAFT_PASS,
+        // port: process.argv[5] || process.env.MINECRAFT_PORT || 58471,
+    }
+
+const bot = mineflayer.createBot(options)
+
+cfg.botOptions = options


 let plugins = {}
@@ -92,13 +95,14 @@ cfg.quiet = true
 bot.once("spawn", () => {
    plugins = {
        command: require('./plugins/command'),
+        eater: require('./plugins/eater'),
+        inventory: require('./plugins/inventory'),
+        informer: require('./plugins/informer'),
+        finder: require('./plugins/finder'),
        sleeper: require('./plugins/sleeper'),
        armor: require('./plugins/armor'),
        mover: require('./plugins/mover'),
        guard: require('./plugins/guard'),
-        inventory: require('./plugins/inventory'),
-        eater: require('./plugins/eater'),
-        finder: require('./plugins/finder'),
        // miner: require('./plugins/miner.js'),
        // statemachine: require('./plugins/statemachine'),
    }
--- a/lib/plugins/command.js
+++ b/lib/plugins/command.js
@@ -1,5 +1,5 @@
 const v = require('vec3')
-let mcData = require('minecraft-data')
+let mcData

 let cfg = {}
 let bot = {}
@@ -46,7 +46,17 @@ const events = {
        }
    }
    , chat: command
-    , kicked: (reason, loggedIn) => console.warn(reason, loggedIn)
+    , kicked: function rejoin(reason, loggedIn) {
+        console.warn(reason, loggedIn && "logged_in")
+        if (reason.extra && reason.extra[0].text === "Server closed") {
+            bot.quit()
+            bot.end()
+            // TODO implement all startup features (maybe refactor all into a single function / module?)
+            setTimeout((bot, cfg) => {
+                bot = mineflayer.createBot(cfg.botOptions)
+            }, 15 * 60 * 1000, bot, cfg);
+        }
+    }
 }

 const events_registered = []
@@ -183,104 +193,33 @@ function command(username, message) {
                    break;

                case "follow":
-                    subcommand("go follow me")
+                    switch (message_parts.length) {
+                        case 1:
+                            subcommand("go follow me")
+                            break;
+
+                        default:
+                            subcommand("go " + message)
+                            break;
+                    }
                    break;
                case "come":
-                    subcommand("go follow once")
+                    switch (message_parts[1]) {
+                        case "close":
+                        case "closer":
+                            subcommand("go follow close")
+                            break
+                        case "up":
+                        case "down":
+                            cfg.plugins.mover.moveY(player.position)
+                            break
+                        default:
+                            subcommand("go follow once")
+                    }
                    break;
                case "move":
                case "go":
-                    // TODO move most of the subcommands into mover.js?
-                    const message_parts2 = message_parts.slice(2)
-                    switch (message_parts[1]) {
-                        case "init":
-                            cfg.plugins.mover.initMoves()
-                            break
-                        case "near":
-                            // message_parts2 = message_parts.slice(2)
-                            switch (message_parts2.length) {
-                                case 0:
-                                    cfg.plugins.mover.moveNear(bot.nearestEntity().position)
-                                    break
-                                case 1:
-                                    switch (message_parts2[0]) {
-                                        case "me":
-                                            if (player) {
-                                                cfg.plugins.mover.moveNear(player.position)
-                                            } else {
-                                                cfg.quiet || bot.chat("can't see you")
-                                            }
-                                            break;
-
-                                        default:
-                                            const aPlayer = bot.players[message_parts[2]] ? bot.players[message_parts[2]].entity : null
-                                            if (aPlayer) {
-                                                cfg.plugins.mover.moveNear(aPlayer.position)
-                                            } else {
-                                                cfg.quiet || bot.chat(`can't see ${message_parts[2]}`)
-                                            }
-                                            break;
-                                    }
-                                    break
-                                case 2:
-                                    todo()
-                                    // bot.lookAt({}) goalxz?
-                                    break
-                                case 3:
-                                    //TODO more checks
-                                    cfg.plugins.mover.moveNear(message_parts2)
-                                    break
-                                default:
-                                    break
-                            }
-                            break
-
-                        case "follow":
-                            // message_parts2 = message_parts.slice(2)
-                            switch (message_parts2.length) {
-                                case 0:
-                                    cfg.plugins.mover.follow(bot.nearestEntity())
-                                    break
-                                case 1:
-                                    switch (message_parts2[0]) {
-                                        case "me":
-                                        case "once":
-                                            if (player) {
-                                                cfg.plugins.mover.follow(player, message_parts2[0] !== "once")
-                                            } else {
-                                                cfg.quiet || bot.chat("can't see you")
-                                            }
-                                            break;
-
-                                        default:
-                                            const aPlayer = bot.players[message_parts[2]] ? bot.players[message_parts[2]].entity : null
-                                            if (aPlayer) {
-                                                cfg.plugins.mover.follow(aPlayer)
-                                            } else {
-                                                cfg.quiet || bot.chat(`can't see ${message_parts[2]}`)
-                                            }
-                                            break;
-                                    }
-                                    break
-                                // case 2:
-                                // bot.lookAt({}) goalxz?
-                                // break
-                                // case 3:
-                                //TODO more checks
-                                // cfg.plugins.mover.moveNear(message_parts2)
-                                // break
-                                default:
-                                    todo()
-                                    break
-                            }
-                            break
-                        case "stop":
-                            cfg.plugins.mover.stop()
-                            break
-                        default:
-                            return todo()
-                            break;
-                    }
+                    cfg.plugins.mover.command(message_parts.slice(1), player)
                    break;

                case "attack":
@@ -331,6 +270,8 @@ function command(username, message) {
                            break;
                    }
                    break
+                // TODO move look (and maybe find) to informer plugin?
+                case "look":
                case "lookat":
                    // const coords = v(message_parts.splice(1))
                    switch (message_parts.length) {
@@ -349,13 +290,12 @@ function command(username, message) {

                                case "this":
                                    // TODO lookat the block the user is looking at
+                                    // Currently looks player position
                                    if (player) {
-                                        bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position))
-                                        todo()
+                                        bot.lookAt(player.position)
                                    } else {
                                        cfg.quiet || bot.chat("can't see you")
                                    }
-                                    break;
                                    break
                                default:
                                    const aPlayer = bot.players[message_parts[2]] ? bot.players[message_parts[2]].entity : null
@@ -375,6 +315,9 @@ function command(username, message) {
                            break
                    }
                    break
+                case "info":
+                    cfg.plugins.informer.command(message_parts.splice(1))
+                    break
                case "ride":
                case "mount":
                    bot.mount(bot.nearestEntity())
@@ -416,29 +359,52 @@ function command(username, message) {
                // case "take":
                //     // TODO take only what's requested, then throw all the rest
                //     // TODO take all
-                // case "toss":
-                // case "drop":
-                //     if (!message_parts[1]) { return false } // FIXME, works but ugly
-                //     if (!checkItemExists(message_parts[1])) { return false }
-                //     switch (message_parts.length) {
-                //         case 2:
-                //             bot.toss(mcData.blocksByName[message_parts[1]].id)
-                //             break
-                //         case 3:
-                //             bot.tossStack(
-                //                 mcData.itemsByName[message_parts[1]].id,
-                //                 (err) => {
-                //                     if (err) {
-                //                         console.log(err)
-                //                         bot.chat(err)
-                //                     }
-                //                 }
-                //             )
-                //             break
-                //         default:
-                //             break
-                //     }
-                //     break;
+
+                // TODO move subcommands to cfg.plugins.inventory.itemByName
+                case "toss":
+                case "drop":
+                    if (!message_parts[1]) { return false } // FIXME, works but ugly
+                    if (!mcData.findItemOrBlockByName(message_parts[1])) {
+                        console.log("doesn't exist:", message_parts[1])
+                        cfg.quiet || bot.chat(`item doesn't exist: ${message_parts[1]}`)
+                        return false
+                    }
+                    const item = cfg.plugins.inventory.itemByName(message_parts[1])
+                    if (!item) {
+                        console.log("don't have:", message_parts[1])
+                        cfg.quiet || bot.chat(`don't have item: ${message_parts[1]}`)
+                        return false
+                    }
+                    switch (message_parts.length) {
+                        case 2:
+                            bot.tossStack(
+                                item,
+                                (err) => {
+                                    if (err) {
+                                        console.error(err)
+                                        cfg.quiet || bot.chat(err.message)
+                                    }
+                                }
+                            )
+                            break
+                        case 3:
+                            const amount = parseInt(message_parts[2])
+                            bot.toss(
+                                item.type,
+                                null, //metadata
+                                amount,
+                                (err) => {
+                                    if (err) {
+                                        console.error(err)
+                                        cfg.quiet || bot.chat(err.message)
+                                    }
+                                }
+                            )
+                            break
+                        default:
+                            break
+                    }
+                    break;
                case "location":
                    // TODO put in /lib/location
                    switch (message_parts[1]) {
@@ -537,13 +503,12 @@ const load = (config) => {
    cfg = config
    bot = cfg.bot

-    mcData = mcData(bot.version)
+    mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
    for (const [key, fn] of Object.entries(events)) {
        events_registered.push(
            bot.on(key, fn)
        )
    }
-    mcData = require('minecraft-data')(bot.version)
 }

 const unload = () => {
--- a/lib/plugins/informer.js
+++ b/lib/plugins/informer.js
@@ -0,0 +1,128 @@
+let cfg
+let bot
+let mcData
+const v = require('vec3')
+
+function block(pos) {
+    const block = pos ? bot.blockAt(v(pos)) : bot.blockAtCursor()
+    console.log(block, block && block.getProperties())
+    if (!block) {
+        cfg.quiet || bot.chat("empty block")
+        return block
+    }
+    let info = [block.type, block.name]
+    if (block.metadata) info.push(Object.entries(block.getProperties()))
+    cfg.quiet || bot.chat(info.join(": "))
+}
+
+function item(
+    slot,
+    entity = bot.entity
+) {
+    const item = slot ?
+        bot.inventory.slots[parseInt(slot) + bot.QUICK_BAR_START] :
+        entity.heldItem
+    console.log(item)
+    if (!item) {
+        cfg.quiet || bot.chat("no item")
+        return item
+    }
+    let info = [item.type, item.name]
+    if (item.metadata) info.push("meta: " + item.metadata.length)
+    if (item.nbt) {
+        info.push(compound_value(item.nbt))
+    }
+    cfg.quiet || bot.chat(info.join("; "))
+    function compound_value(obj) {
+        if (typeof obj.value == "object") {
+            return compound_value(obj.value)
+        } else if (obj.value) {
+            return obj.value
+        } else if (typeof obj == "object") {
+            const keys = Object.keys(obj)
+            return keys.map(key => {
+                return `${key}: ${compound_value(obj[key])}`
+            });
+        } else {
+            return obj
+        }
+    }
+    return item
+}
+
+function entity(name) {
+    const entity = bot.nearestEntity((entity) => {
+        const ename = entity.name || entity.username
+        return name && ename ? ename == name : true
+    })
+    console.log(entity)
+    if (!entity) {
+        cfg.quiet || bot.chat("no entity")
+        return entity
+    }
+    let info = [entity.type, entity.name || entity.username]
+    if (entity.metadata) info.push("len: " + entity.metadata.length)
+    cfg.quiet || bot.chat(info.join("; "))
+}
+
+function command(message_parts) {
+    switch (message_parts.length) {
+        case 0:
+            // TODO most recent command?
+            block()
+            break;
+        case 1:
+            switch (message_parts[0]) {
+                case "item":
+                    item()
+                    break
+                case "entity":
+                    entity()
+                    break
+                case "block":
+                default:
+                    block()
+                    break;
+            }
+
+            break;
+
+        case 2:
+            switch (message_parts[0]) {
+                case "item":
+                    item(message_parts[1])
+                    break
+                case "entity":
+                default:
+                    entity(message_parts[1])
+                    break;
+            }
+            break
+
+        case 4:
+            switch (message_parts[0]) {
+                case "block":
+                default:
+                    block(message_parts.slice(1))
+                    break;
+            }
+
+            break;
+
+        default:
+            break;
+    }
+}
+
+const load = (config) => {
+    cfg = config
+    bot = cfg.bot
+    cfg.info = {
+        quiet: cfg.quiet,
+    }
+    mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
+}
+
+const unload = () => {}
+
+module.exports = { load, unload, command, block, item, entity }
--- a/lib/plugins/inventory.js
+++ b/lib/plugins/inventory.js
@@ -225,4 +225,4 @@ const unload = () => {
    bot.off('chat', inventory)
 }

-module.exports = { load, unload, equipItem, craftItem }
+module.exports = { load, unload, equipItem, craftItem, itemByName }
--- a/lib/plugins/mover.js
+++ b/lib/plugins/mover.js
@@ -1,27 +1,28 @@
-// import { EntityFilters } from "mineflayer-statemachine"
-// import v from "vec3"

-// import { Movements } from "mineflayer-pathfinder"
-
-// const mineflayer = require('mineflayer')
 const { Movements } = require('mineflayer-pathfinder')
-// const { GoalBLah } = require('mineflayer-pathfinder').goals
 const v = require('vec3')

 let cfg = {}
 let bot = {}
 // let moving
 let pathfinder
+let mcData
 let movements = []


-function initMoves(bot = bot, mcData = require('minecraft-data')(bot.version)) {
+function initMoves(bot = bot, mcData = bot.mcData) {
+    console.info(movements)
+    if (movements.length > 0) {
+        bot.pathfinder.setMovements(movements.defaultMove)
+        return console.warn("movements already initialized!")
+    }
    let defaultMove = new Movements(bot, mcData)
    defaultMove.canDig = false
    defaultMove.scafoldingBlocks.push(mcData.blocksByName.slime_block.id)
-    // defaultMove.blocksCantBreak.add(mcData.blocksByName.glass.id)
-    // defaultMove.blocksToAvoid.add(mcData.blocksByName.magma.id)
-    movements.defaultMove = defaultMove
+    defaultMove.blocksCantBreak.add(mcData.blocksByName.glass.id)
+    defaultMove.blocksToAvoid.add(mcData.blocksByName.magma_block.id)
+    movements.push(defaultMove)
+    movements.defaultMove = movements[0]

    bot.pathfinder.setMovements(defaultMove)
 }
@@ -29,19 +30,43 @@ function initMoves(bot = bot, mcData = require('minecraft-data')(bot.version)) {

 function moveNear(pos, distance = 3) {
    const { GoalNear } = require('mineflayer-pathfinder').goals
-    cfg.quiet || bot.chat(`moving to ${pos}`)

    pos = v(pos)
+    cfg.quiet || bot.chat(`moving to ${pos.floored()}`)
    bot.pathfinder.setMovements(movements.defaultMove)
    bot.pathfinder.setGoal(new GoalNear(pos.x, pos.y, pos.z, distance))
 }

-function follow(entity, dynamic = true) {
+function moveXZ(pos) {
+    const { GoalXZ } = require('mineflayer-pathfinder').goals
+
+    if (Array.isArray(pos) && pos.length == 2) {
+        pos = v(pos[0], 0, pos[1])
+    }
+    pos = v(pos)
+    console.log(pos)
+    cfg.quiet || bot.chat(`moving to ${pos.floored()}`)
+    bot.pathfinder.setMovements(movements.defaultMove)
+    bot.pathfinder.setGoal(new GoalXZ(pos.x, pos.z))
+}
+
+function moveY(pos) {
+    const { GoalY } = require('mineflayer-pathfinder').goals
+
+    if (Array.isArray(pos) && pos.length == 1) {
+        pos = v(null, pos[0], null)
+    }
+    pos = v(pos)
+    console.log(pos)
+    cfg.quiet || bot.chat(`moving to ${pos.floored()}`)
+    bot.pathfinder.setMovements(movements.defaultMove)
+    bot.pathfinder.setGoal(new GoalY(pos.y))
+}
+
+function follow(entity, dynamic = true, distance = 3) {
    console.assert(entity)
    const { GoalFollow } = require('mineflayer-pathfinder').goals

-
-
    cfg.quiet && console.log(entity)
        || bot.chat(
            `following ${entity.type
@@ -54,18 +79,158 @@ function follow(entity, dynamic = true) {
    // console.log(entity)

    bot.pathfinder.setMovements(movements.defaultMove)
-    bot.pathfinder.setGoal(new GoalFollow(entity, 3), dynamic)
+    bot.pathfinder.setGoal(new GoalFollow(entity, distance), dynamic)
 }

 function hit(blockOrEntity) {
    bot.chat(`hitting ${entity.name || entity.type}`)
 }

+function goalReached(goal) {
+    console.log(goal)
+    const entity = goal?.entity
+    let entityInfo = ""
+    if (entity) {
+        entityInfo += entity.type + ": "
+        switch (entity.type) {
+            case "player":
+                entityInfo += entity.username
+                break;
+            default:
+                break;
+        }
+    }
+    cfg.quiet || bot.chat(`goal reached: ${entityInfo}; pos: [x:${goal?.x}, y:${goal?.y}, z:${goal?.z}]`)
+}
+
 function stop() {
    bot.pathfinder.setGoal(null)
    bot.stopDigging()
 }

+function command(message_parts, player) {
+    const message_parts2 = message_parts.slice(1)
+    switch (message_parts[0]) {
+        case "init":
+            initMoves()
+            break
+        case "near":
+            switch (message_parts2.length) {
+                case 0:
+                    moveNear(bot.nearestEntity().position)
+                    break
+                case 1:
+                    switch (message_parts2[0]) {
+                        case "me":
+                            if (player) {
+                                moveNear(player.position)
+                            } else {
+                                cfg.quiet || bot.chat("can't see you")
+                            }
+                            break;
+
+                        default:
+                            const aPlayer = bot.players[message_parts2[0]] ? bot.players[message_parts2[0]].entity : null
+                            if (aPlayer) {
+                                moveNear(aPlayer.position)
+                            } else {
+                                cfg.quiet || bot.chat(`can't see ${message_parts2[0]}`)
+                            }
+                            break;
+                    }
+                    break
+                case 2:
+                    //TODO this isn't near
+                    moveXZ(message_parts2)
+                    break
+                case 3:
+                    //TODO more checks
+                    moveNear(message_parts2)
+                    break
+                default:
+                    break
+            }
+            break
+
+        case "follow":
+            // message_parts2 = message_parts.slice(2)
+            switch (message_parts2.length) {
+                case 0:
+                    follow(bot.nearestEntity())
+                    break
+                case 1:
+                    let dist = 3
+                    switch (message_parts2[0]) {
+                        case "close":
+                            dist = 1
+                        case "me":
+                        case "once":
+                            if (player) {
+                                follow(player, message_parts2[0] === "me", dist)
+                            } else {
+                                cfg.quiet || bot.chat("can't see you")
+                            }
+                            break;
+
+                        default:
+                            const aPlayer = bot.players[message_parts2[0]] ? bot.players[message_parts2[0]].entity : null
+                            if (aPlayer) {
+                                follow(aPlayer)
+                            } else {
+                                cfg.quiet || bot.chat(`can't see ${message_parts2[0]}`)
+                            }
+                            break;
+                    }
+                    break
+                // case 2:
+                // bot.lookAt({}) goalxz?
+                // break
+                // case 3:
+                //TODO more checks
+                // moveNear(message_parts2)
+                // break
+                default:
+                    cfg.quiet || bot.chat("unknown or bad command")
+                    break
+            }
+            break
+        case "w":
+        case "f":
+            command(["forward"].concat(message_parts.slice(1)))
+            break
+        case "s":
+        case "b":
+            command(["back"].concat(message_parts.slice(1)))
+            break
+        case "a":
+        case "l":
+            command(["right"].concat(message_parts.slice(1)))
+            break
+        case "d":
+        case "r":
+            command(["left"].concat(message_parts.slice(1)))
+            break
+        case "back":
+        case "forward":
+        case "jump":
+        case "left":
+        case "right":
+        case "sneak":
+        case "sprint":
+            console.info(bot.controlState[message_parts[0]], bot.entity.position.floored())
+            bot.setControlState(message_parts[0], true)
+            console.info(bot.controlState[message_parts[0]])
+            setTimeout(bot.setControlState, 200 * (message_parts[1] || 1), message_parts[0], false)
+            setTimeout(console.info, 5000, bot.controlState[message_parts[0]], bot.entity.position.floored())
+            break
+        case "stop":
+            stop()
+            break
+        default:
+            return cfg.quiet || bot.chat(`unknown command ${message_parts[0]}`)
+    }
+}
+
 const load = (config) => {
    cfg = config
    bot = cfg.bot
@@ -77,19 +242,18 @@ const load = (config) => {
        movements: []
    }

+    mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
    pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder)

    // initMoves(bot, mcData)
-    setTimeout(initMoves, 500, bot)
-
-    // bot.loadPlugin(pathfinder)
-
-    // bot.on('time', hello)
+    setTimeout(initMoves, 500, bot, mcData)
+    bot.on('goal_reached', goalReached)

 }

 const unload = () => {
-    // TODO stop pathfinding maybe?
+    stop()
+    bot.off('goal_reached', goalReached)
 }

-module.exports = { load, unload, stop, initMoves, moveNear, follow }
+module.exports = { load, unload, command, stop, initMoves, moveNear, moveXZ, moveY, follow }
--- a/lib/plugins/sleeper.js
+++ b/lib/plugins/sleeper.js
@@ -7,49 +7,78 @@ let bot = {}
 let inv
 // cfg.autosleep = false

-function sleep(quiet) {
-    quiet = quiet !== undefined ? quiet : cfg.sleep.quiet
+function sleep(quiet = cfg.sleep.quiet) {
    if(bot.game.dimension !== "minecraft:overworld" || cfg.sleep.force){
        !quiet && bot.chat("can't sleep, not in overworld now")
        return
    }
+    if (bot.isSleeping && !cfg.sleep.force) {
+        !quiet && bot.chat("already in bed!")
+        return
+    }
    let bed = bot.findBlock({
        matching: block => bot.isABed(block)
    })
-    let bedstatus = bed && bot.parseBedMetadata(bed).occupied ? "n unoccupied" : ""
-    if(bed && bedstatus == "n unoccupied"){
+    let bed_occupied = bed && bot.parseBedMetadata(bed).occupied
+    if (bed && bed_occupied) {
        bot.lookAt(bed.position)
        bed = bot.findBlock({
            matching: block => bot.isABed(block) && !bot.parseBedMetadata(block).occupied
        }) || bed
-        bedstatus = bot.parseBedMetadata(bed).occupied ? "n unoccupied" : ""
+        bed_occupied = bot.parseBedMetadata(bed).occupied
    }
-    if (bed && bedstatus == "") {
+    if (bed && !bed_occupied) {
        bot.lookAt(bed.position)
        bot.waitForChunksToLoad(() => {
-            cfg.plugins.moveNear(bed.position)
-            bot.sleep(bed, (err) => {
-                if (err) {
-                    !quiet && bot.chat(`can't sleep: ${err.message}`)
-                } else {
-                    !quiet && bot.chat("zzz")
-                    console.log("sleeping? ", bot.isSleeping)
-                    // hack until this is fixed
-                    // bot.isSleeping = bot.isSleeping ? bot.isSleeping : true
-                    bot.isSleeping = true
+            cfg.plugins.mover && cfg.plugins.mover.moveNear(bed.position, 2)
+            bot.once('goal_reached', (goal) => {
+                console.info(goal)
+                try {
+                    bot.sleep(bed, (err) => {
+                        if (err) {
+                            !quiet && bot.chat(`can't sleep: ${err.message}`)
+                        } else {
+                            !quiet && bot.chat("zzz")
+                            // apparently, `bot.isSleeping = true` takes a while
+                            // maybe it's async
+                            console.log("sleeping? ", bot.isSleeping)
+                        }
+                    })
+                } catch (error) {
+                    console.error(error)
                }
            })
        })
-    } else if (inv && inv.equipItem("red_bed", "hand", true)) {
-        // doesn't work fortunately
-        // FIXME: DONT IMPLEMENT until it is detected as NOT NETHER
-        // bot.placeBlock()
+    } else if (bed = bot.inventory.items().filter(bot.isABed)[0]) {
+        const v = require('vec3')
+        bot.equip(bed, "hand", (err) => { if (err) console.error(err) })
+        bot.waitForChunksToLoad(() => {
+            let refBlock =
+                // FIXME hack to get around findBlock returning null
+                bot.blockAt(bot.entity.position.offset(1, 0, 1), false)
+            // bot.findBlock({
+            //     matching: (block) => {
+            //         // if (block && block.type !== 0 && block.position) {
+            //         if (block && block.position) {
+            //             console.info("found", block)
+            //             const blockAbove = bot.blockAt(block.position.offset(0, 1, 0))
+            //             return !blockAbove || blockAbove.type === 0
+            //         }
+            //         // console.info("not found", block)
+            //         return false
+            //     }
+            //     , maxDistance: 10
+            // })
+            console.log(refBlock)
+            bot.placeBlock(refBlock, new v.Vec3(0, 1, 0), console.error)
+            setTimeout(sleep, 3000, true)
+        })
    } else {
        // TODO: use mover
        // bot.gameplay.solveFor(
        //     new ObtainItem("bed"), (err) => {
        //         if (err) {
-        //             !quiet && bot.chat(`need a${bedstatus} bed: may not see if just placed`)
+        !quiet && bot.chat(`need a${bed_occupied ? "n unoccupied" : ""} bed: may not see if just placed`)
        //         }
        //     }
        // )
@@ -72,7 +101,7 @@ function autoSleep() {
    if (!bot.time.isDay && !cfg.sleep.timeoutFn && cfg.sleep.auto && !bot.isSleeping) {
        sleep()
        cfg.sleep.timeoutFn = setTimeout(() => { cfg.sleep.timeoutFn = null }, cfg.sleep.timeout)
-        console.log("sleeping?", bot.isSleeping, bot.time)
+        console.log("sleeping?", bot.isSleeping, bot.time.isDay, bot.time.timeOfDay)
    }
 }

--- a/package.json
+++ b/package.json
@@ -34,20 +34,20 @@
    "require-self": "^0.2.3"
  },
  "dependencies": {
-    "minecraft-data": "^2.70.2",
-    "mineflayer": "^2.34.0",
-    "mineflayer-armor-manager": "^1.3",
-    "mineflayer-pathfinder": "^1.1",
-    "mineflayer-pvp": "^1",
-    "prismarine-block": "^1",
-    "prismarine-chat": "^1",
+    "dotenv-packed": "^1.2.1",
+    "minecraft-data": "^2.73.1",
+    "mineflayer": "^2.40.1",
+    "mineflayer-armor-manager": "^1.4.0",
+    "mineflayer-pathfinder": "^1.3.6",
+    "mineflayer-pvp": "^1.0.2",
+    "prismarine-block": "^1.7.3",
+    "prismarine-chat": "^1.0.3",
    "prismarine-entity": "^1.1.0",
    "prismarine-item": "^1.5.0",
-    "prismarine-nbt": "^1.3",
-    "prismarine-recipe": "^1",
-    "typescript": "^4",
-    "vec3": "^0.1",
-    "dotenv-packed": "^1.2"
+    "prismarine-nbt": "^1.4.0",
+    "prismarine-recipe": "^1.1.0",
+    "typescript": "^4.1.3",
+    "vec3": "^0.1.7"
  },
  "files": [
    "lib/**/*"
Author	SHA1	Message	Date
jay	974d460061	feat(mover): ✨ add basic movement commands Forward, left, etc. Uses bot.controlState. But left and right does the opposite of expectations.	2021-01-18 15:13:53 +05:00
jay	1d361e04a6	build: ⬆️ update deps	2021-01-18 01:54:05 +05:00
jay	7597620626	ci: 🔧 add vscode conventional commits scopes	2021-01-18 01:47:32 +05:00
jay	e5faa6f022	feat(informer): ✨ add more detail to item info Gives detail of traversing the item's nbt data	2021-01-18 01:24:47 +05:00
jay	cc18ac5c2e	refactor(mover): 🚚 move commands inside mover plugin itself This reduces the code inside the command plugin. Most of the logic was only relevant to moving anyway. Command aliases like `come` and `follow` still remain in command plugin.	2021-01-17 23:59:39 +05:00
jay	7050a1621b	fix(informer): 🐛 add missing name for entity info when entity is a player Uses `username` when `entity.name` is missing; should check other cases	2021-01-17 18:32:05 +05:00
jay	7cbfa16476	feat(informer): ✨ add case for when sub command is passed a single param Currently returns: - Item at given slot number - Entity that matches given name	2021-01-17 16:20:20 +05:00
jay	63849e0729	fix(informer): 🥅 catch and report when objects are missing	2021-01-17 16:16:41 +05:00
jay	4e7f8d59fd	feat(informer): ✨ add more detailed block metadata info Uses `block.getProperties()`. Thanks to a [comment][1] [1]: https://github.com/PrismarineJS/mineflayer-pathfinder/pull/84/files#r541196424	2021-01-17 15:54:31 +05:00
jay	7b2b936f81	feat(mover): ✨ implement moveY (vertical move up or down) Doesn't appear to be working properly, bot assumes XZ is goal reached	2021-01-17 13:56:18 +05:00
jay	8a39596b1d	feat(informer): ✨ add info for block at given position	2021-01-17 13:02:05 +05:00
jay	2601b7cfb1	fix(informer): 🥅 fix crash for block info when no block or an empty block is found	2021-01-17 12:20:49 +05:00
jay	67932b2f6a	fix(sleeper): 🥅 catch sleeping edge case errors Happens when trying to sleep while previously unable to move. Or maybe when trying to sleep during dawn.	2021-01-16 16:39:42 +05:00
jay	9a6e684b11	feat(informer): ✨ add info about nearest entities	2021-01-16 16:17:42 +05:00
jay	3488a94233	feat(informer): ✨ info about held item(s)	2021-01-16 14:51:49 +05:00
jay	4d21327086	fix(mover): 🚸 better messages	2021-01-16 13:57:21 +05:00
jay	e74d796124	fix(command): 🐛 make `follow` command work again without params	2021-01-16 13:50:35 +05:00
jay	3d5ffe38cd	feat(mover): ✨ inform when goal reached	2021-01-16 13:25:26 +05:00
jay	b519913355	feat(mover): ✨ implement moving to X Z goal (without y)	2021-01-15 00:36:17 +05:00
jay	b1dab1968c	fix(command): ✏️ fix `follow` command not working	2021-01-05 11:34:49 +05:00
jay	3219ec6155	feat(informer): ✨ actually add a command for info plugin	2021-01-05 11:32:33 +05:00
jay	f38ad8c819	fix(command): 🚧 fix and workaround bot look at `this` Workaround being unable to look at what player is looking at. Currently looks at what player is standing on.	2021-01-05 09:30:14 +05:00
jay	4b8a39d38c	feat(informer): ✨ add optional metadata to block info display	2021-01-05 09:20:35 +05:00
jay	6b71de0356	refactor(informer): 🚚 proper name to block info function Be more specific: `block` instead of `info`. In anticipation of future functions in this module.	2021-01-05 08:52:38 +05:00
jay	96214ffe37	fix(informer): 🐛 use block.type instead of block.id `block.id` is nonexistent when tested live	2021-01-05 08:32:30 +05:00
jay	034f8d331a	fix(informer): 🐛 convert array to string for chat `bot.chat` only supports strings	2021-01-05 08:18:21 +05:00
jay	69d0f5830d	feat(mover): ✨ add close(er) command to follow / come closer	2021-01-05 08:11:11 +05:00
jay	8e719d5ccf	feat(sleeper): ✨ add and adjust functionality to properly sleep Can now use beds in inventory but with a hacky block placing workaround. `findBlock` returns a null position. So it uses the closest adjacent block and assumes it'll work. Bot also is more robust at sleeping,	2020-12-27 05:50:16 +05:00
jay	112eb04a8d	refactor(sleeper): ♻️ simplify and make sleeping code more robust	2020-12-27 01:58:17 +05:00
jay	ba7c53be0c	refactor(command): ♻️ make toss exit early if non-existent block	2020-12-27 00:30:46 +05:00
jay	5b4718fa5d	fix(command): 🐛 add missing return	2020-12-25 07:29:06 +05:00
jay	902732c6dd	chore: ⬆️ update deps	2020-12-25 07:20:05 +05:00
jay	65d13a3379	style: fix crlf -> lf	2020-12-25 07:17:54 +05:00
jay	288b7045b6	feat: ✨ add informer plugin to show info Data and information plugin. Expose methods in mcData with acceptable ux. Also central place for all kinds of debug features.	2020-12-24 21:39:50 +05:00
jay	94574a4296	refactor: ♻️ reorder plugin loading Load in order of simplicity and dependance. TODO: Use `bot.waitForChunksToLoad`: Split plugins based on whether it requires blocks to be loaded or no.	2020-12-24 21:32:08 +05:00
jay	68e60921b1	refactor(mover): 🔥 remove unused code + comments, minor fixes Refactoring and fixing code. No major functionality change. Probably will have less bugs. - carry over how mcData is loaded - stop bot on unload - fix wrong magma block name	2020-12-24 19:57:45 +05:00
jay	f2281a7cb3	feat(command): ✨ temp. move inventory chat handling to command This is temporary, and only the `toss` function. Old functionality is still intact. New code will eventually move back as a subcommand to replace the old.	2020-12-24 19:41:52 +05:00
jay	e9f2080556	refactor(command): ♻️ refactor how mcData is loaded `mcData` is now directly put on bot and loaded once. It can be accessed from anywhere `bot` is accessible.	2020-12-24 17:51:44 +05:00
jay	086251bce6	feat: add a basic feature to rejoin on server restart	2020-12-24 13:38:16 +05:00
jay	0ae961521f	feat(command): ✨ expand follow to include rest of the `!go follow` sub commands	2020-12-24 11:57:23 +05:00
jay	eae4e95803	Merge branch 'nogameplay' into master	2020-12-24 11:28:22 +05:00
jay	fb066ee8a5	refactor: ♻️ use array in pathfinder movements list	2020-12-24 11:26:19 +05:00
jay	f4445749e6	fix: ✏️ add missing plugin name	2020-12-24 11:23:16 +05:00