.gitattributes

@@ -1,16 +0,0 @@
-# See this article for reference: https://help.github.com/articles/dealing-with-line-endings/
-# Refreshing repo after line ending change:
-# https://help.github.com/articles/dealing-with-line-endings/#refreshing-a-repository-after-changing-line-endings
-
-# Handle line endings automatically for files detected as text
-# and leave all files detected as binary untouched.
-* text=auto
-
-#
-# The above will handle all files NOT found below
-#
-# These files are text and should be normalized (Convert crlf => lf)
-# Use lf as eol for these files
-*.js    text eol=lf
-*.ts    text eol=lf
-*.json  text eol=lf

.gitignore

@@ -10,7 +10,6 @@
 
 # production
 /build
-/data
 
 # misc
 .DS_Store

.vscode/settings.json

@@ -1,10 +0,0 @@
-{
-    "conventionalCommits.scopes": [
-        "command",
-        "mover",
-        "sleeper",
-        "informer",
-        "statemachine",
-        "builder"
-    ]
-}

lib/index.js

@@ -1,56 +1,50 @@
 const env = require("dotenv-packed").parseEnv().parsed
 const fs = require('fs');
-const cfg = {
-    admin: process.env.MINECRAFT_PLAYER_ADMIN || env.MINECRAFT_PLAYER_ADMIN || console.warn("main: bot admin user not provided"),
-    mods: process.env.MINECRAFT_PLAYER_MODS || env.MINECRAFT_PLAYER_MODS || [], // json array,
+let cfg = {
+    admin: "Applezaus",
+    mods: ["Applezaus", "tanner6", "Angram42", "[WEB] Angram42", "[WEB] Applezaus"],
     stateMachines: {}
 }
 
 const mineflayer = require("mineflayer");
 // const { createGetAccessor } = require('typescript');
 
-const options = !isNaN(parseInt(process.argv[3])) && parseInt(process.argv[3]) > 1e2 ?
-    {
+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 bot = mineflayer.createBot(options)
-
-cfg.botOptions = options
+        })
 
 
 let plugins = {}
 
-function loadplugin(pluginname, pluginpath = './plugins/' + pluginname) {
+function loadplugin(pluginname, pluginpath) {
     try {
         plugins[pluginname] = require(pluginpath)
         plugins[pluginname].load(cfg)
     } catch (error) {
         if (error.code == 'MODULE_NOT_FOUND') {
             console.warn('plugin not used:', pluginpath)
-        } else if (plugins[pluginname] && !plugins[pluginname].load) {
-            unloadplugin(pluginname, pluginpath)
         } else {
             console.error(error)
         }
     }
 }
 
-function unloadplugin(pluginname, pluginpath = './plugins/' + pluginname) {
+function unloadplugin(pluginname, pluginpath) {
+    pluginpath = pluginpath ? pluginpath : './plugins/' + pluginname
     const plugin = require.resolve(pluginpath)
     try {
         if (plugin && require.cache[plugin]) {
-            // `unload()` isn't exported sometimes,
-            // when plugin isn't properly loaded
-            require.cache[plugin].exports?.unload?.()
+            require.cache[plugin].exports.unload()
             delete plugins[pluginname]
             delete require.cache[plugin]
         }
@@ -59,28 +53,20 @@ function unloadplugin(pluginname, pluginpath = './plugins/' + pluginname) {
     }
 }
 
-function reloadplugin(event, filename, pluginpath = './plugins/') {
+reloadplugin = (event, filename, pluginpath) => {
     if (!/\.js$/.test(filename)) { return }
-    filename = filename.replace("\\", "/") // windows
     if (!cfg.fsTimeout) {
         console.info(event, filename)
-        const fullpluginpath = pluginpath + filename
-        const pluginname = (filename.split(".js")[0]).replace(/\/.+/, "")
-        pluginpath = pluginpath + pluginname
-        const hassubplugin = fullpluginpath.replace(/\.js$/, "") !== pluginpath
+        pluginpath = (pluginpath ? pluginpath : './plugins/') + filename
         const check = Object.keys(cfg.plugins)
-        console.info(`reload file: ./lib/${fullpluginpath}`)
-        const plugin = require.resolve(fullpluginpath)
+        console.info(`reload file:`, pluginpath)
+        const plugin = require.resolve(pluginpath)
         if (plugin && require.cache[plugin]) {
             // console.debug(Object.keys(cfg.plugins))
-            unloadplugin(pluginname)
+            unloadplugin(filename.split(".js")[0], pluginpath)
             console.assert(Object.keys(cfg.plugins).length == check.length - 1, "plugin not removed, potential memory leak")
-            if (hassubplugin) {
-                console.info("reload: also unloading sub")
-                unloadplugin(pluginname, fullpluginpath)
         }
-        }
-        loadplugin(pluginname)
+        loadplugin(filename.split(".js")[0], pluginpath)
         if (Object.keys(cfg.plugins).length != check.length) {
             // If left < right :
             //  - new plugin that's not registered in cfg.plugins, so added
@@ -94,11 +80,10 @@ function reloadplugin(event, filename, pluginpath = './plugins/') {
     // console.log('file.js %s event', event)
 }
 
-fs.watch('./lib/plugins', { recursive: true }, reloadplugin)
+fs.watch('./lib/plugins', reloadplugin)
 
 cfg.bot = bot
-// TODO better name, or switch to array
-cfg.botAddressPrefix = '!'
+cfg.botAddress = new RegExp(`^${bot.username} (!.+)`)
 cfg.quiet = true
 
 
@@ -107,23 +92,18 @@ cfg.quiet = true
 bot.once("spawn", () => {
     plugins = {
         command: require('./plugins/command'),
-        informer: require('./plugins/informer'),
-        inventory: require('./plugins/inventory'),
-        finder: require('./plugins/finder'),
-        mover: require('./plugins/mover'),
         sleeper: require('./plugins/sleeper'),
-        eater: require('./plugins/eater'),
         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'),
+        // statemachine: require('./plugins/statemachine'),
     }
 
     cfg.plugins = plugins
-    // cfg.botAddressPrefix = ${bot.username.substr(-2,2)}
-    cfg.botAddressRegex = new RegExp(`^${bot.username}:? (/|${cfg.botAddressPrefix}.+)`)
-    // FIXME leaks every load, so adding here instead of command.js to load only once
-    bot.addChatPattern("web", /\[WEB\] (\[.+\])?\s*([\w.]+): (.+)/, { parse: true })
 
     for (const plugin of Object.values(plugins)) {
         try {

lib/plugins/command.js

@@ -1,5 +1,5 @@
 const v = require('vec3')
-let mcData
+let mcData = require('minecraft-data')
 
 let cfg = {}
 let bot = {}
@@ -27,13 +27,14 @@ function checkItemExists(name) {
 }
 
 const events = {
-    whisper: function command_whisper(username, _botusername, message, ...history) {
-        if ([bot.username, "me"].includes(username)) return // whisper back from server (afk msges, etc)
+    whisper: function command_whisper(username, message) {
+        if ([bot.username, "me"].includes(username)) return
         if (/^gossip/.test(message)) return
+        // if (/^!/.test(message) && username === cfg.admin){
         if (username === cfg.admin) {
-            console.info("whispered command", _botusername, message)
             message = message.replace("\\", "@")
-            if (message.startsWith(cfg.botAddressPrefix)) {
+            console.info("whispered command", message)
+            if (/^!/.test(message)) {
                 command(username, message)
             } else {
                 bot.chat(message)
@@ -41,53 +42,16 @@ const events = {
             }
         } else {
             bot.whisper(cfg.admin, `gossip ${username}: ${message}`)
-            console.info(username, "whispered", _botusername, message)
+            console.info(username, "whispered", message)
         }
     }
     , chat: command
-    , 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);
-        }
-    }
-    // , message: systemMessage
-    , messagestr: function systemMessageStr(...args) { console.log("cmd msgstr:", ...args) }
-    , "chat:web": commandWeb
-}
-
-function systemMessage(...args) {
-    if (args[0]?.text) return
-    const metadata = (args[0]?.extra || args[0]?.with)?.map(v => v.text)
-    console.log(
-        "cmd msg:",
-        args[0]?.text || args[0]?.translate,
-        args[0]?.extra?.length || args[0]?.with?.length || Object.keys(args[0]?.json).length - 1,
-        metadata.length > 0 && metadata || args[0],
-        args.slice(1)
-    )
-}
-
-function commandWeb([[mode, username, message]]) {
-    // console.log("web msg:", mode, username, message)
-    message && command(username, message)
-}
-
-function _clientSystemMessage(...args) {
-    console.log("cmd chat:", args[0]?.message, args[0]?.extra?.length, args[0]?.extra, args[0], args.slice(1))
+    , kicked: (reason, loggedIn) => console.warn(reason, loggedIn)
 }
 
 const events_registered = []
 
 function command(username, message) {
-    // TODO better name, maybe an array?
-    cfg.botAddressPrefix = cfg.botAddressPrefix || "!"
-
     function fuzzyRespond(responses, probability = 1, timeout = 1) {
         if (Math.random() < probability) {
             const response = responses[Math.floor(Math.random() * responses.length)]
@@ -102,7 +66,7 @@ function command(username, message) {
         }
     }
 
-    if (username === bot.username && !message.startsWith(cfg.botAddressPrefix)) return
+    if (username === bot.username && !message.startsWith("!")) return
 
     const player = bot.players[username] ? bot.players[username].entity : null
 
@@ -114,12 +78,11 @@ function command(username, message) {
     }
 
 
-    if (message.startsWith(cfg.botAddressPrefix) || cfg.botAddressRegex.test(message)) {
-        message = cfg.botAddressRegex.test(message) ? cfg.botAddressRegex.exec(message)[1] : message
-        console.log(message)
-        // remove `!`
-        message = message.startsWith(cfg.botAddressPrefix) ? message.slice(cfg.botAddressPrefix.length) : message
+    if (message.startsWith("!") || cfg.botAddress.test(message)) {
+        message = cfg.botAddress.test(message) ? cfg.botAddress.exec(message)[1] : message
 
+        console.log(message)
+        message = message.slice(1) // remove `!`
         // TODO command dispatchEvent, for aliases
         function subcommand(message) {
             const message_parts = message.split(/\s+/)
@@ -220,44 +183,104 @@ function command(username, message) {
                     break;
 
                 case "follow":
-                    switch (message_parts.length) {
-                        case 1:
                     subcommand("go follow me")
                     break;
+                case "come":
+                    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:
-                            subcommand("go " + message)
-                            break;
+                                            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;
-                case "come":
-                    switch (message_parts[1]) {
-                        case "close":
-                        case "closer":
-                            subcommand("go follow close")
+                                    }
                                     break
-                        case "up":
-                        case "down":
-                            cfg.plugins.mover.moveY(player.position)
+                                case 2:
+                                    todo()
+                                    // bot.lookAt({}) goalxz?
+                                    break
+                                case 3:
+                                    //TODO more checks
+                                    cfg.plugins.mover.moveNear(message_parts2)
                                     break
                                 default:
-                            subcommand("go follow once")
+                                    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;
-                case "ride":
-                case "mount":
-                    cfg.plugins.mover.command(message_parts)
+
+                                        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 "unride":
-                case "getoff":
-                case "unmount":
-                case "dismount":
-                    bot.dismount()
-                    bot.vehicle = void 0
+                                // case 2:
+                                // bot.lookAt({}) goalxz?
+                                // break
+                                // case 3:
+                                //TODO more checks
+                                // cfg.plugins.mover.moveNear(message_parts2)
+                                // break
+                                default:
+                                    todo()
                                     break
-                case "move":
-                case "go":
-                    cfg.plugins.mover.command(message_parts.slice(1), player)
+                            }
+                            break
+                        case "stop":
+                            cfg.plugins.mover.stop()
+                            break
+                        default:
+                            return todo()
+                            break;
+                    }
                     break;
 
                 case "attack":
@@ -308,8 +331,6 @@ 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) {
@@ -320,7 +341,7 @@ function command(username, message) {
                             switch (message_parts[1]) {
                                 case "me":
                                     if (player) {
-                                        bot.lookAt(player.position.offset(0, 1, 0))
+                                        bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position))
                                     } else {
                                         cfg.quiet || bot.chat("can't see you")
                                     }
@@ -328,16 +349,17 @@ function command(username, message) {
 
                                 case "this":
                                     // TODO lookat the block the user is looking at
-                                    // Currently looks player position
                                     if (player) {
-                                        bot.lookAt(player.position)
+                                        bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position))
+                                        todo()
                                     } 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
-                                    if (aPlayer) bot.lookAt(aPlayer.position.offset(0, 1, 0))
+                                    if (aPlayer) bot.lookAt((new v.Vec3(0, 1, 0)).add(aPlayer.position))
                                     break;
                             }
                             break
@@ -353,8 +375,17 @@ function command(username, message) {
                             break
                     }
                     break
-                case "info":
-                    cfg.plugins.informer.command(message_parts.splice(1), player)
+                case "ride":
+                case "mount":
+                    bot.mount(bot.nearestEntity())
+                    break
+                case "getoff":
+                case "unmount":
+                case "dismount":
+                    bot.dismount()
+                    break
+                case "go":
+                    bot.moveVehicle(0, 10)
                     break
                 // case "use":
                 //     bot.useOn(bot.nearestEntity())
@@ -385,62 +416,29 @@ function command(username, message) {
                 // case "take":
                 //     // TODO take only what's requested, then throw all the rest
                 //     // TODO take all
-
-                // 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 "sm":
-                case "step":
-                    cfg.plugins.statemachine?.command?.(
-                        message_parts[0] == "sm" ? message_parts.slice(1) : message_parts, player
-                    )
-                        // TODO refactor into plugin detection and command exec function
-                        // safecommand(plugin_name, message_parts, player)
-                        // message_parts includes command?
-                        || bot.chat("statemachine plugin not loaded")
-                    break
+                // 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;
                 case "location":
                     // TODO put in /lib/location
                     switch (message_parts[1]) {
@@ -498,7 +496,7 @@ function command(username, message) {
             case "howdy":
             case "heyo":
             case "yo":
-                if (player) bot.lookAt(player.position.offset(0, 1, 0))
+                if (player) bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position))
 
                 // TODO sneak
                 // function swingArm() {
@@ -539,14 +537,13 @@ const load = (config) => {
     cfg = config
     bot = cfg.bot
 
-    mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
+    mcData = mcData(bot.version)
     for (const [key, fn] of Object.entries(events)) {
         events_registered.push(
             bot.on(key, fn)
         )
     }
-
-    // bot._client.on("chat", _clientSystemMessage)
+    mcData = require('minecraft-data')(bot.version)
 }
 
 const unload = () => {
@@ -556,8 +553,6 @@ const unload = () => {
         events_registered.shift()
     }
     console.log("events_registered:", bot._eventsCount)
-
-    // bot._client.off("chat", _clientSystemMessage)
 }
 
 module.exports = { load, unload, events_registered, command }

lib/plugins/eater.js

@@ -2,7 +2,11 @@ let cfg = {}
 let bot = {}
 let isEating = false
 
-function eat(callback = e => e && console.error(e)) {
+function callbackHandle(err) {
+    if (err) console.error(err)
+}
+
+function eat(callback) {
     isEating = true
 
     const foodNames = require('minecraft-data')(bot.version).foodsArray.map((item) => item.name)
@@ -33,23 +37,23 @@ function eat(callback = e => e && console.error(e)) {
 
     bot.equip(best_food, 'hand', function (error) {
         if (error) {
-            console.warn(error, best_food)
+            console.error(error)
             isEating = false
             bot.emit('eat_stop')
         } else {
-            try {
-                bot.consume().catch(error => {
-                    if (error.message === "Food is full") {
-                        console.warn(error, best_food)
+            bot.consume(function (err) {
+                if (err) {
+                    console.error(err)
+                    isEating = false
+                    bot.emit('eat_stop')
+                    return callback(err)
                 } else {
-                        return callback({ error, best_food })
+                    isEating = false
+                    bot.emit('eat_stop')
+                    callback(null)
+                    if (!bot.food === 20) eat(callbackHandle)
                 }
-                }).finally(() => {
-                    isEating = false
-                    bot.emit('eat_stop')
             })
-            } catch { }
-            if (bot.food !== 20) eat(callback)
         }
     })
 }
@@ -72,7 +76,7 @@ function checkFood() {
                 // TODO implement better idle state
             ) || true // idle most likely
         ) {
-            eat()
+            eat(callbackHandle)
         }
     }
 }

lib/plugins/guard.js

@@ -71,7 +71,9 @@ function lookForMobs() {
         bot.pvp.attack(entityEnemy)
     } else if (entityEnemy) {
         bot.lookAt(
+            // (new v.Vec3(0, 1, 0)).add(
             entityEnemy.position
+            // )
         )
         cfg.quiet || bot.chat("AH! A creeper! They creep me out!")
     }

lib/plugins/informer.js

@@ -1,342 +0,0 @@
-let bot
-let mcData
-let quiet
-// import v from 'vec3'
-const v = require('vec3')
-
-let cfg = {
-    info: {
-        quiet: quiet,
-        recentCommand: null,
-    },
-    // to satisfy typescript
-    quiet: null,
-    bot: bot
-}
-
-var RelativePosEnum
-(function (RelativePosEnum) {
-    RelativePosEnum[RelativePosEnum["feet"] = 0] = "feet"
-    RelativePosEnum[RelativePosEnum["standing"] = 1] = "standing"
-    RelativePosEnum[RelativePosEnum["head"] = 2] = "head"
-    RelativePosEnum[RelativePosEnum["looking"] = 3] = "looking"
-    RelativePosEnum[RelativePosEnum["infront"] = 4] = "infront"
-    RelativePosEnum[RelativePosEnum["behind"] = 5] = "behind"
-})(RelativePosEnum || (RelativePosEnum = {}))
-
-function relPosToBlock(entity, relPos) {
-    let pos
-    if (!(relPos in RelativePosEnum)) return console.warn("info: not a relative position:", relPos)
-    relPos = typeof relPos === "number" ? RelativePosEnum[relPos] : relPos
-    switch (relPos) {
-        case "feet":
-            pos = entity.position;
-            break
-        case "standing":
-            pos = entity.position.offset(0, -1, 0)
-            break
-        // todo use CARDINAL directions api from pathfinder
-        // case "behind":
-        //     entity.yaw
-        //     pos = entity.position
-        //     break
-        // case "front":
-        // case "infront":
-        //     pos = entity.position
-        //     break
-        case "head":
-            pos = entity.position.offset(0, 1.85, 0)
-            break
-        case "looking":
-            if (entity === bot.entity) {
-                return bot.blockAtCursor()
-                // return bot.blockInSight(128, 128)
-            }
-        default:
-            quiet || bot.chat(`info: pos '${relPos}' not implemented`)
-            break
-    }
-    if (pos) {
-        // nearest block
-        return bot.blockAt(pos)
-    }
-}
-
-function isVec3(vec) {
-    return vec?.length === 3 || vec.x && vec.y && vec.z
-}
-
-function block(entity = bot.entity, pos = entity?.position?.offset(0, -1, 0)) {
-    console.assert(pos || entity)
-    const block = isVec3(pos) ? bot.blockAt(v(pos))
-        : typeof pos === "string" ? relPosToBlock(entity, RelativePosEnum[pos]) : pos
-    console.log(block, block?.getProperties && block.getProperties())
-    if (!block) {
-        quiet || bot.chat("empty block")
-        return block
-    }
-    bot.lookAt(block?.position)
-    let info = [block.type, block.name]
-    if (block.metadata) info.push(Object.entries(block.getProperties()))
-    quiet || bot.chat(info.join(": "))
-}
-
-function item(
-    entity = bot.entity,
-    slot = entity.heldItem
-) {
-    const item = typeof slot === "number" ?
-        bot.inventory.slots[slot + bot.QUICK_BAR_START] :
-        slot
-    console.log("info item:", item)
-    if (!item) {
-        quiet || bot.chat("no item")
-        return item
-    }
-    let info = [item.type, item.name, item.count]
-    if (item.metadata) info.push("meta: " + item.metadata.length)
-    if (item.nbt) {
-        info.push(compound_value(item.nbt))
-    }
-    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
-}
-
-var VillagerProfession
-(function (VillagerProfession) {
-    VillagerProfession[VillagerProfession["Unemployed"] = 0] = "Unemployed"
-    VillagerProfession[VillagerProfession["Armourer"] = 1] = "Armourer"
-    VillagerProfession[VillagerProfession["Butcher"] = 2] = "Butcher"
-    VillagerProfession[VillagerProfession["Cartographer"] = 3] = "Cartographer"
-    VillagerProfession[VillagerProfession["Cleric"] = 4] = "Cleric"
-    VillagerProfession[VillagerProfession["Farmer"] = 5] = "Farmer"
-    VillagerProfession[VillagerProfession["Fisherman"] = 6] = "Fisherman"
-    VillagerProfession[VillagerProfession["Fletcher"] = 7] = "Fletcher"
-    VillagerProfession[VillagerProfession["Leatherworker"] = 8] = "Leatherworker"
-    VillagerProfession[VillagerProfession["Librarian"] = 9] = "Librarian"
-    VillagerProfession[VillagerProfession["Mason"] = 10] = "Mason"
-    VillagerProfession[VillagerProfession["Nitwit"] = 11] = "Nitwit"
-    VillagerProfession[VillagerProfession["Shepherd"] = 12] = "Shepherd"
-    VillagerProfession[VillagerProfession["Toolsmith"] = 13] = "Toolsmith"
-    VillagerProfession[VillagerProfession["Weaponsmith"] = 14] = "Weaponsmith"
-})(VillagerProfession || (VillagerProfession = {}))
-
-function entity(name = bot.nearestEntity()) {
-    const entity = typeof name === "string" ? (name = name.toLowerCase()) && bot.nearestEntity((entity) => {
-        const enames = [entity.username?.toLowerCase(), entity.name, entity.displayName?.toLowerCase()]
-        return enames.includes(name)
-    }) : name
-    console.log("info entity:", entity)
-    if (!entity) {
-        quiet || bot.chat("no entity")
-        return entity
-    }
-    entity?.position && bot.lookAt(entity.position)
-    let info = [(entity.entityType && entity.entityType + ":" || "") + (entity.type === "object" ? entity.kind : entity.type)]
-    info.push(entity.username || entity.name)
-    // TODO various info depending on the type of entity; player, villager, etc
-    // TODO refactor and combine with compound_value()
-    switch (entity.type) {
-        case "object":
-            switch (entity.kind) {
-                case "Drops":
-                    const item = entity.metadata[7];
-                    entity.metadata;
-                    if (item.present) {
-                        info.push("item: " + item.itemId + ": "
-                            + mcData.items[item.itemId].name
-                            + `x${item.itemCount}`);
-                    }
-                    else {
-                        console.warn("info entity: metadata expected item, got:", entity.metadata[7]);
-                    }
-                    break;
-                default:
-            }
-            break;
-        case "mob":
-            switch (name) {
-                case 'villager':
-                    const { villagerProfession, ...otherProps } = entity.metadata[17]
-                    info.push(VillagerProfession[villagerProfession])
-                    info.push(Object.entries(otherProps).toString())
-                    break
-                default:
-                    break
-            }
-
-            entity.metadata[8] && info.push("health:" + entity.metadata[8])
-            entity.metadata[15] && info.push("baby")
-            if (entity.heldItem) {
-                info.push("holding")
-                item(entity)
-            }
-        case "global":
-        case "orb":
-        case "player":
-            break;
-        case "other":
-            info.push("kind:" + entity.kind)
-        default:
-    }
-    if (entity.metadata) info.push("len: " + entity.metadata.length)
-    quiet || bot.chat(info.join("; "))
-    return entity
-}
-
-function blockOrItemFromId(num, quiet = cfg.info.quiet) {
-    const block = mcData?.blocks[num]
-    const item = mcData?.items[num]
-    // const entity = mcData?.entities[num]
-    if (block || item) {
-        quiet || bot.chat(
-            (block && `block: ${block.name}, ` || "")
-            + (item && `item: ${item.name}, ` || "")
-            // + (entity && `entity: ${entity.name}, ` || "")
-        )
-    } else {
-        quiet || bot.chat("info: nonexistent block or item")
-    }
-    return { block, item }
-}
-
-function command(message_parts, player) {
-    if (message_parts.length > 0) {
-        cfg.info.recentCommand = message_parts
-    }
-    if (player === null)
-        player = void 0
-    switch (message_parts.length) {
-        case 0:
-            if (cfg.info.recentCommand) {
-                command(cfg.info.recentCommand, player)
-            } else {
-                // TODO dispatch on instance of entity, block, etc..
-                // TODO have the logic inside the function or with a utility function
-                block()
-            }
-            break;
-        case 1:
-            switch (message_parts[0]) {
-                case "quiet":
-                    cfg.info.quiet = quiet = !quiet;
-                    quiet || bot.chat(`info: ${quiet ? "" : "not "}being quiet`);
-                    break;
-                case "i":
-                case "item":
-                    item()
-                    break
-                case "e":
-                case "entity":
-                    entity()
-                    break
-                case "me":
-                    block(player)
-                    break
-                case "b":
-                case "block":
-                    block()
-                    break
-                default:
-                    const num = parseInt(message_parts[0])
-                    if (isFinite(num)) {
-                        blockOrItemFromId(num)
-                    } else {
-                        quiet || bot.chat("info usage: `!info [me|i|e|b|<num>|quiet]`")
-                    }
-                    break;
-            }
-
-            break;
-
-        case 2:
-            switch (message_parts[0]) {
-                case "i":
-                case "item":
-                    switch (message_parts[1]) {
-                        case "me":
-                            item(player)
-                            break
-                        default:
-                            const slot = parseInt(message_parts[1])
-                            slot && item(undefined, slot)
-                            break
-                    }
-                    break
-                case "b":
-                case "block":
-                    switch (message_parts[1]) {
-                        case "me":
-                            block(player)
-                            break
-                        default:
-                            const aPlayer = bot.players[message_parts[1]]
-                            if (message_parts[1] in RelativePosEnum) {
-                                block(undefined, message_parts[1])
-                            } else if (aPlayer) {
-                                if (aPlayer.entity) {
-                                    block(aPlayer.entity)
-                                } else {
-                                    quiet || bot.chat(`info: player ${aPlayer.username} too far!`)
-                                }
-                            } else {
-                                // or entity(message_parts[1]).position
-                                console.log(bot.players[message_parts[1]])
-                                quiet || bot.chat("info: not yet implemented")
-                            }
-                    }
-                    break
-                case "me":
-                    if (message_parts[1] in RelativePosEnum) {
-                        block(player, message_parts[1])
-                    }
-                    break
-                case "e":
-                case "entity":
-                default:
-                    entity(message_parts[1])
-                    break;
-            }
-            break
-
-        case 4:
-            switch (message_parts[0]) {
-                case "b":
-                case "block":
-                default:
-                    block(undefined, message_parts.slice(1))
-                    break;
-            }
-
-            break;
-
-        default:
-            cfg.quiet || bot.chat("info: unknown command")
-            break;
-    }
-}
-
-const load = (config) => {
-    config.info = cfg.info
-    cfg = config
-    bot = cfg.bot
-    mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
-}
-
-const unload = () => {}
-
-module.exports = { load, unload, command, block, item, entity }

lib/plugins/inventory.js

@@ -225,4 +225,4 @@ const unload = () => {
     bot.off('chat', inventory)
 }
 
-module.exports = { load, unload, equipItem, craftItem, itemByName }
+module.exports = { load, unload, equipItem, craftItem }

lib/plugins/mover.js

@@ -1,86 +1,49 @@
+// 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 = bot.mcData) {
-    if (movements.length > 0) {
-        bot.pathfinder.setMovements(movements.defaultMove)
-        return console.warn("go init: movements already initialized!", movements)
-    }
-    const normalMove = new Movements(bot, mcData)
-    normalMove.canDig = false
-    normalMove.scafoldingBlocks.push(mcData.blocksByName.slime_block.id)
-    normalMove.blocksCantBreak.add(mcData.blocksByName.glass.id)
-    normalMove.blocksToAvoid.add(mcData.blocksByName.magma_block.id)
-    movements.push(normalMove)
-    movements.defaultMove = movements[0]
+function initMoves(bot = bot, mcData = require('minecraft-data')(bot.version)) {
+    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
 
-    const aggresiveMove = new Movements(bot, mcData)
-    //Object.create or assign?
-    Object.assign(aggresiveMove, normalMove)
-    aggresiveMove.canDig = true
-    movements.push(aggresiveMove)
-
-    const safeMove = new Movements(bot, mcData)
-    Object.assign(safeMove, normalMove)
-    safeMove.allowParkour = false
-    safeMove.canDig = false
-    movements.push(safeMove)
-    // console.info("go init: moves:", movements)
-
-    bot.pathfinder.setMovements(normalMove)
+    bot.pathfinder.setMovements(defaultMove)
 }
 
 
 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 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) {
+function follow(entity, dynamic = true) {
     console.assert(entity)
     const { GoalFollow } = require('mineflayer-pathfinder').goals
 
-    // console.log(entity)
-    cfg.quiet || bot.chat(
+
+
+    cfg.quiet && console.log(entity)
+        || bot.chat(
             `following ${entity.type
             }: ${entity.username || entity.displayName
             }${dynamic ? "" : " once"}`
@@ -91,265 +54,18 @@ function follow(entity, dynamic = true, distance = 3) {
     // console.log(entity)
 
     bot.pathfinder.setMovements(movements.defaultMove)
-    bot.pathfinder.setGoal(new GoalFollow(entity, distance), dynamic)
-}
-
-function away(entity = bot.nearestEntity(), invertInvert = true, dynamic = true, distance = 10) {
-    const currentGoal = bot.pathfinder.goal
-    console.assert(currentGoal || entity)
-    const { GoalInvert } = require('mineflayer-pathfinder').goals
-
-    bot.pathfinder.setMovements(movements.defaultMove)
-
-    if (!currentGoal) {
-        const { GoalFollow } = require('mineflayer-pathfinder').goals
-
-        if (entity.entity) {
-            console.log("go away entity:", entity, entity.entity)
-            entity = entity.entity
-        }
-
-        cfg.quiet || bot.chat(
-            `going away from ${entity?.type
-            }: ${entity?.username || entity?.displayName
-            }${dynamic ? "" : " once"}`
-        )
-        // alternative implementation
-        // follow(entity, dynamic, distance)
-        // bot.pathfinder.setGoal(new GoalInvert(bot.pathfinder.goal), dynamic)
-        return bot.pathfinder.setGoal(new GoalInvert(
-            new GoalFollow(entity, distance)
-        ), dynamic)
-    }
-
-    if (currentGoal instanceof GoalInvert) {
-        const currEntity = currentGoal.goal.entity
-        console.log("go away inverse goal:", currentGoal.goal)
-        if (invertInvert) {
-            cfg.quiet || bot.chat(
-                `switching towards ${currentGoal.goal?.constructor.name
-                }: ${currEntity?.type
-                }: ${currEntity?.username || currEntity?.displayName
-                }${dynamic ? "" : " once"}`
-            )
-            bot.pathfinder.setGoal(currentGoal.goal, dynamic)
-        } else {
-            cfg.quiet || bot.chat(
-                `already going away from ${currentGoal.goal?.constructor.name
-                }; not switching`
-            )
-        }
-    } else {
-        const currEntity = currentGoal.entity
-        console.log("go away goal:", currentGoal)
-        cfg.quiet || bot.chat(
-            `going away from ${currentGoal?.constructor.name
-            }: ${currEntity?.type
-            }: ${currEntity?.username || currEntity?.displayName
-            }${dynamic ? "" : " once"}`
-        )
-        bot.pathfinder.setGoal(new GoalInvert(currentGoal), dynamic)
-    }
-
-
-}
-
-function ride(entity) {
-    entity = entity?.entity || entity
-    const ridableMobs = ["Horse", "Donkey", "Pig", "Strider", "Mule"]
-    const vehicle = entity && typeof entity !== "string" ? entity : bot.nearestEntity(e => {
-        if (typeof entity === "string") return e.name === entity
-        const maybeRidableMob = e.mobType?.split(" ")
-        return e.kind == "Vehicles"
-            || ridableMobs.includes(e.mobType)
-            || maybeRidableMob && ridableMobs.includes(maybeRidableMob[maybeRidableMob.length - 1])
-    })
-    if (!vehicle) {
-        return cfg.quiet || bot.chat(`nothing to ride!`)
-    } else if ((dist = bot.entity.position.distanceSquared(vehicle.position)) > 36) {
-        bot.lookAt(vehicle.position)
-        follow(vehicle, false)
-        bot.once('goal_reached', ride)
-        return cfg.quiet || bot.chat(`${vehicle.name} bit far`)
-    }
-    console.log("vehicle:", vehicle)
-    bot.mount(vehicle)
-}
-
-function moveOrRide(turn = false, reverse = -1, directionLabel, message_parts2) {
-    // bot.once("attach", state = "vehiccel")
-    if (bot.vehicle) {
-        // FIXME moveVehicle should be +-1 or 0?
-        const amount = parseInt(message_parts2[0]) * -reverse
-        bot.moveVehicle(turn && Math.sign(amount) || 0, !turn && amount || 0)
-    } else {
-        command([directionLabel].concat(message_parts2))
-    }
+    bot.pathfinder.setGoal(new GoalFollow(entity, 3), 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 "ride":
-        case "mount":
-            ride(message_parts2[0])
-            break
-        case "away":
-        case "run":
-        case "runaway":
-            away()
-            break
-        case "w":
-        case "f":
-            moveOrRide(0, -1, "forward", message_parts2)
-            break
-        case "s":
-        case "b":
-            moveOrRide(0, 1, "back", message_parts2)
-            break
-        case "a":
-        case "l":
-            moveOrRide(1, -1, "right", message_parts2)
-            break
-        case "d":
-        case "r":
-            moveOrRide(1, 1, "left", message_parts2)
-            break
-        case "up":
-        case "u":
-        case "j":
-            moveOrRide(1, 1, "jump", message_parts2)
-            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, 100 * (message_parts[1] || 2), 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
@@ -361,23 +77,19 @@ 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, mcData)
-    bot.on('goal_reached', goalReached)
+    setTimeout(initMoves, 500, bot)
+
+    // bot.loadPlugin(pathfinder)
+
+    // bot.on('time', hello)
 
 }
 
 const unload = () => {
-    stop()
-    bot.off('goal_reached', goalReached)
+    // TODO stop pathfinding maybe?
 }
 
-module.exports = {
-    load, unload, command,
-    stop, initMoves,
-    moveNear, moveXZ, moveY, follow,
-    ride
-}
+module.exports = { load, unload, stop, initMoves, moveNear, follow }

lib/plugins/sleeper.js

@@ -7,78 +7,49 @@ let bot = {}
 let inv
 // cfg.autosleep = false
 
-function sleep(quiet = cfg.sleep.quiet) {
+function sleep(quiet) {
+    quiet = quiet !== undefined ? 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 bed_occupied = bed && bot.parseBedMetadata(bed).occupied
-    if (bed && bed_occupied) {
+    let bedstatus = bed && bot.parseBedMetadata(bed).occupied ? "n unoccupied" : ""
+    if(bed && bedstatus == "n unoccupied"){
         bot.lookAt(bed.position)
         bed = bot.findBlock({
             matching: block => bot.isABed(block) && !bot.parseBedMetadata(block).occupied
         }) || bed
-        bed_occupied = bot.parseBedMetadata(bed).occupied
+        bedstatus = bot.parseBedMetadata(bed).occupied ? "n unoccupied" : ""
     }
-    if (bed && !bed_occupied) {
+    if (bed && bedstatus == "") {
         bot.lookAt(bed.position)
         bot.waitForChunksToLoad(() => {
-            cfg.plugins.mover && cfg.plugins.mover.moveNear(bed.position, 2)
-            bot.once('goal_reached', (goal) => {
-                console.info(goal)
-                try {
+            cfg.plugins.moveNear(bed.position)
             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)
+                    // hack until this is fixed
+                    // bot.isSleeping = bot.isSleeping ? bot.isSleeping : true
+                    bot.isSleeping = true
                 }
             })
         })
-    } 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 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 {
         // TODO: use mover
         // bot.gameplay.solveFor(
         //     new ObtainItem("bed"), (err) => {
         //         if (err) {
-        !quiet && bot.chat(`need a${bed_occupied ? "n unoccupied" : ""} bed: may not see if just placed`)
+        //             !quiet && bot.chat(`need a${bedstatus} bed: may not see if just placed`)
         //         }
         //     }
         // )
@@ -101,7 +72,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.isDay, bot.time.timeOfDay)
+        console.log("sleeping?", bot.isSleeping, bot.time)
     }
 }
 

lib/plugins/statemachine.js

@@ -1,479 +1,115 @@
-// import { createMachine, interpret, InterpreterStatus } from "xstate";
-const { createMachine, interpret, InterpreterStatus } = require('xstate');
-// import { access, mkdir, writeFile, readFile } from "fs";
-const { access, mkdir, writeFile, readFile } = require('fs');
-// ANGRAM_PREFIX='MINECRAFT'
-const { MINECRAFT_DATA_FOLDER } = process.env || require("dotenv-packed").parseEnv().parsed;
-const storage_dir = MINECRAFT_DATA_FOLDER || './data/' + "/sm/";
-// import { createBot } from "mineflayer"
-// let { pathfinder, Movements, goals } = require('mineflayer-pathfinder')
-// let cfg
-// let bot = createBot({ username: 'statebot' })
-let bot;
-let quiet;
-let updateRate = 20;
-const machines = {
-    list: {},
-    running: {},
-};
-let webserver;
-let cfg = {
-    statemachine: {
-        webserver: null,
-        // quiet: true,
-        quiet: quiet,
-        list: {},
-        running: {},
-        draft: null,
-        recent: null,
-        // debug: null,
-        debug: true,
-        updateRate: updateRate
-    }
-    // FIXME temp variables to satisfy typescript autocomplete
-    // , quiet: null
-    ,
-    bot: bot,
-    plugins: { statemachine: null }
-};
-// Edit your machine(s) here
-function init(smName = "dummy", webserver) {
-    access(storage_dir, err => {
-        if (err?.code === 'ENOENT') {
-            mkdir(storage_dir, e => e && console.warn("sm init: create dir", e));
-        }
-        else if (err) {
-            console.warn("sm init: create dir", err);
-        }
-    });
-    // const machine = newSM(smName)
-    // machine.states.idle.on.TOGGLE = "start"
-    // machine.states.start.on.TOGGLE = "idle"
-    const machine = createMachine({
-        id: smName,
-        initial: "idle",
-        states: {
-            idle: {
-                on: { TOGGLE: "start", NEXT: "start", PREV: "look", STOP: "finish" }
-            },
-            start: {
-                on: { TOGGLE: "look", NEXT: "look", PREV: "idle" },
-                entry: 'lookAtPlayerOnce',
-            },
-            look: {
-                on: { TOGGLE: "idle", NEXT: "idle", PREV: "start" },
-                // entry: ['look', 'blah']
-                // entry: 'lookAtPlayerOnce',
-                activities: 'lookAtPlayer',
-                meta: { debug: true }
-            },
-            finish: {
-                type: 'final'
-            },
-        },
-        on: { START: '.start', STOP: '.idle' },
-        meta: { debug: true },
-        context: { player: null, rate: updateRate },
-    }, {
-        actions: {
-            // action implementation
-            lookAtPlayerOnce: (context, event) => {
-                const player = context?.player && (context?.player?.isValid || context?.player?.entity?.isValid)
-                    || bot.nearestEntity(entity => entity.type === 'player');
-                if (player?.position || player?.entity) {
-                    context.player = player;
-                    bot.lookAt((player.entity || player).position.offset(0, 1, 0));
-                }
-            }
-        },
-        activities: {
-            lookAtPlayer: (context, event) => {
-                const player = (context?.player?.isValid || context?.player?.entity?.isValid) && context?.player
-                    || bot.nearestEntity(entity => entity.type === 'player' && entity.isValid);
-                // TODO check pos every event?
-                if (player?.position || player?.entity) {
-                    context.player = player;
-                    function looks() {
-                        bot.lookAt((player.entity || player).position.offset(0, 1, 0));
-                    }
-                    bot.on("time", looks);
-                    return () => bot.off("time", looks);
-                }
-                else {
-                    quiet || bot.chat("look: no valid players");
-                    // TODO use xstate logger
-                    context.debug && console.log("sm: no valid player", this, context, player);
-                }
-            }
-        },
-        delays: {
-            /* ... */
-        },
-        guards: {
-            /* ... */
-        },
-        services: {
-            /* ... */
-        }
-    });
-    console.log("sm init: machine", machine);
-    const service = runSM(saveSM(machine));
-    if (service?.send) {
-        setTimeout(service.send, 200, "TOGGLE");
-        // setTimeout(service.send, 400, "TOGGLE")
-    }
-    else {
-        console.warn("sm init: service", service);
-    }
+// Load your dependency plugins.
+
+const {pathfinder} = require('mineflayer-pathfinder')
+// bot.loadPlugin(require('prismarine-viewer').mineflayer)
+// const mineflayerViewer = require('prismarine-viewer').mineflayer
+
+// Import required behaviors.
+const {
+    StateTransition,
+    BotStateMachine,
+    EntityFilters,
+    BehaviorFollowEntity,
+    BehaviorLookAtEntity,
+    BehaviorGetClosestEntity,
+    NestedStateMachine,
+    BehaviorIdle,
+    StateMachineWebserver,
+} = require("mineflayer-statemachine");
+
+// TODO chat
+
+
+
+// wait for our bot to login.
+function statemachineInit() {
+    cfg.botAddress = new RegExp(`^${bot.username} (!.+)`)
+    // This targets object is used to pass data between different states. It can be left empty.
+    const targets = new Object();
+
+    // Create our states
+    const getClosestPlayer = new BehaviorGetClosestEntity(
+        bot, targets, entity => EntityFilters().PlayersOnly(entity) && bot.entity.position.distanceTo(entity.position) <= 50 ); // && a.username !== bot.username);
+    const followPlayer = new BehaviorFollowEntity(bot, targets);
+    const lookAtPlayer = new BehaviorLookAtEntity(bot, targets);
+    const stay = new BehaviorIdle();
+
+    // Create our transitions
+    const transitions = [
+
+        // We want to start following the player immediately after finding them.
+        // Since getClosestPlayer finishes instantly, shouldTransition() should always return true.
+        new StateTransition({
+            parent: getClosestPlayer,
+            child: followPlayer,
+            onTransition: (quiet) => quiet || bot.chat(`Hi ${targets.entity.username}!`),
+            shouldTransition: () => bot.entity.position.distanceTo(targets.entity.position) <= 50,
+            // shouldTransition: () => getClosestPlayer.distanceToTarget() < 100 || console.info("player too far!") && false,
+        }),
+
+        // If the distance to the player is less than two blocks, switch from the followPlayer
+        // state to the lookAtPlayer state.
+        new StateTransition({
+            parent: followPlayer,
+            child: lookAtPlayer,
+            // onTransition: () => console.log(targets),
+            shouldTransition: () => followPlayer.distanceToTarget() < 2,
+        }),
+
+        // If the distance to the player is more than two blocks, switch from the lookAtPlayer
+        // state to the followPlayer state.
+        new StateTransition({
+            parent: lookAtPlayer,
+            child: followPlayer,
+            shouldTransition: () => lookAtPlayer.distanceToTarget() >= 5,
+        }),
+        new StateTransition({
+            parent: lookAtPlayer,
+            child: stay,
+            onTransition: () => bot.chat("ok, staying"),
+            // shouldTransition: () => true,
+        }),
+        new StateTransition({
+            parent: stay,
+            child: getClosestPlayer,
+            // shouldTransition: () => Math.random() > 0.01,
+            // shouldTransition: () => Math.random() > 0.1 && getClosestPlayer.distanceToTarget() < 2,
+        }),
+    ];
+
+    // Now we just wrap our transition list in a nested state machine layer. We want the bot
+    // to start on the getClosestPlayer state, so we'll specify that here.
+    const rootLayer = new NestedStateMachine(transitions, getClosestPlayer, stay);
+
+    // We can start our state machine simply by creating a new instance.
+    cfg.stateMachines.follow = new BotStateMachine(bot, rootLayer);
+    const webserver = new StateMachineWebserver(bot, cfg.stateMachines.follow);
+    webserver.startServer();
+
+    // mineflayerViewer(bot, { port: 3000 })
+    // const path = [bot.entity.position.clone()]
+    // bot.on('move', () => {
+    //     if (path[path.length - 1].distanceTo(bot.entity.position) > 1) {
+    //         path.push(bot.entity.position.clone())
+    //         bot.viewer.drawLine('path', path)
+    //     }
+    // })
 }
-function newSM(smName = "sm_" + Object.keys(cfg.statemachine.list).length) {
-    smName = smName.replace(/\s+/, '_');
-    if (cfg.statemachine.list[smName]) {
-        console.warn("sm exists", smName);
-        quiet || bot.chat(`sm ${smName} already exists, edit or use another name instead`);
-        return;
-    }
-    const machine = createMachine({
-        id: smName,
-        initial: "start",
-        // TODO use history states for PAUSE and RESUME
-        states: { idle: { on: { START: "start" } }, start: { on: { STOP: "idle" } } }
-    });
-    cfg.statemachine.draft = machine;
-    return machine;
+
+const load = (config) => {
+    cfg = config
+    bot = cfg.bot
+    // cfg.inventory = {
+    //     auto: true,
+    //     quiet: false
+    // }
+    // bot.on('chat', inventory)
+    bot.loadPlugin(pathfinder)
+    // statemachineInit()
 }
-function saveSM(machine = cfg.statemachine.draft) {
-    if (!machine?.id) {
-        console.warn("sm save: invalid", machine);
-        quiet || bot.chat("sm: couldn't save, invalid");
-        return;
-    }
-    // TODO do tests and validation
-    // 1. ensure default states [start, idle]
-    // 2. ensure closed cycle from start to idle
-    cfg.statemachine.list[machine.id] = machine;
-    if (machine.id === cfg.statemachine.draft?.id) {
-        cfg.statemachine.draft = null;
-    }
-    writeFile(
-        // TODO
-        // `${storage_dir}/${player}/${machine.id}.json`
-        `${storage_dir}/${machine.id}.json`,
-        // TODO decide which data to store
-        // https://xstate.js.org/docs/guides/states.html#persisting-state
-        // JSON.stringify(machine.toJSON),
-        // JSON.stringify(machine.states.toJSON), // + activities, delays, etc
-        JSON.stringify({ config: machine.config, context: machine.context }), e => e && console.log("sm load sm: write file", e));
-    // return run ? runSM(machine) : machine
-    return machine;
+
+const unload = () => {
+    // bot.off('chat', inventory)
 }
-function loadSM(name, run = true) {
-    //: StateMachine<any, any, any> {
-    readFile(
-        // readFileSync(
-        // TODO
-        // `${storage_dir}/${player}/${machine.id}.json`
-        `${storage_dir}/${name}.json`, afterRead
-        // JSON.stringify(machine.toJSON),
-    );
-    function afterRead(err, jsonString) {
-        if (err) {
-            console.warn("sm load sm: read file", err);
-            return;
-        }
-        else {
-            const machine = createMachine(JSON.parse(jsonString).config);
-            // TODO do tests and validation
-            // 1. ensure default states [start, idle]
-            // 2. ensure closed cycle from start to idle
-            cfg.statemachine.list[machine.id] = machine;
-            if (machine.id === cfg.statemachine.draft?.id) {
-                cfg.statemachine.draft = machine;
-            }
-            if (run) {
-                runSM(machine);
-            }
-        }
-    }
-    // return run ? runSM(machine) : machine
-    // return machine
-}
-// function isInterpreter(SMorService: StateMachine<any, any, any> | Interpreter<any>): SMorService is Interpreter<any> {
-//   return (SMorService as Interpreter<any>).start !== undefined;
-// }
-function getSM(name = cfg.statemachine.draft || cfg.statemachine.recent, asService = false, quiet = false) {
-    const machine = typeof name === "string" ? cfg.statemachine.list[name]
-        : name;
-    if (!machine) {
-        console.warn("sm get: doesn't exist", name);
-        cfg.statemachine.quiet || bot.chat(`sm ${name} doesn't exist`);
-        return;
-    }
-    if (asService) {
-        const service = cfg.statemachine.running[machine?.id];
-        if (!service) {
-            quiet || console.warn("sm get: already stopped", machine);
-            quiet || cfg.statemachine.quiet || bot.chat(`sm ${machine?.id} isn't running`);
-            return interpret(machine);
-        }
-        return service;
-    }
-    else {
-        // return machine.machine ? machine.machine : machine
-        return machine;
-    }
-}
-function runSM(name = getSM(undefined, undefined, true), player // or supervisor?
-    , restart = false) {
-    if (!name)
-        return;
-    const service = getSM(name, true, true);
-    if (!service)
-        return;
-    const machine = service.machine;
-    if (!machine)
-        return;
-    switch (service.status) {
-        case InterpreterStatus.Running:
-            if (!restart) {
-                console.warn("sm run: already running", service.id);
-                quiet || bot.chat(`sm ${service.id} already running`);
-                return service;
-            }
-            stopSM(machine);
-        case InterpreterStatus.NotStarted:
-        case InterpreterStatus.Stopped:
-            break;
-        default:
-            console.warn("sm run: unknown status:", service.status, service);
-            return;
-            break;
-    }
-    if (cfg.statemachine.debug || machine.meta?.debug) {
-        service.onTransition((state) => {
-            quiet || bot.chat(`sm trans: ${machine.id}, ${state.value}`);
-            quiet || state.meta?.debug && bot.chat(`sm next events: ${machine.id}, ${state.nextEvents}`);
-            console.log("sm debug: trans", state.value, state);
-        }).onDone((done) => {
-            quiet || bot.chat(`sm done: ${machine.id}, ${done}`);
-            console.log("sm debug: done", done.data, done);
-        });
-    }
-    cfg.statemachine.running[machine.id] = service;
-    cfg.statemachine.recent = machine;
-    service.start();
-    // return machine
-    return service;
-}
-function stopSM(name = getSM(), quiet = false) {
-    let service = getSM(name, true, quiet);
-    if (!service)
-        return;
-    const machine = service.machine;
-    switch (service.status) {
-        case InterpreterStatus.NotStarted:
-        case InterpreterStatus.Stopped:
-            console.log("sm stop status", service.status, service.id, cfg.statemachine.running[service.id]);
-        // TODO check if any bugs
-        case InterpreterStatus.Running:
-            break;
-        default:
-            console.warn("sm stop: unknown status:", service.status);
-            break;
-    }
-    service?.stop?.();
-    cfg.statemachine.running[machine.id] = null;
-    delete cfg.statemachine.running[machine.id];
-    // return machine
-    return service;
-}
-function actionSM(action, name = getSM()) {
-    if (!action) {
-        return console.warn("sm action", action);
-    }
-    let service = getSM(name, true, true);
-    if (service.status !== InterpreterStatus.Running)
-        return;
-    // const machine = service.machine
-    service.send(action.toUpperCase());
-}
-function stepSM(command = "", ...message_parts) {
-    let service = getSM(undefined, true);
-    if (!service)
-        return;
-    if (!service.send) {
-        console.warn("sm step: can't send", service.machine);
-        // TODO start a temporary service to interpret
-        quiet || bot.chat("sm: step doesn't support machines that aren't running yet");
-        return;
-    }
-    if (service?.status !== InterpreterStatus.Running) {
-        console.warn("sm step: machine not running, attempting start", service);
-        runSM;
-    }
-    // const machine = service.machine
-    switch (command) {
-        case "edit":
-            // maybe `edit <type>`, like `add`?
-            // where type:
-            // context
-            // action
-            // timeout | all timeout
-            break;
-        case "undo":
-            break;
-        case "del":
-            break;
-        case "p":
-        case "prev":
-            service?.send("PREV");
-            break;
-        case "add":
-        // maybe `add <type>`?
-        // where type:
-        // context
-        // action
-        // timeout
-        case "new":
-            break;
-        // case "with":
-        //   console.log(this)
-        //   stepSM(getSM(message_parts[0], true, true), ...message_parts.slice(1))
-        //   break;
-        case "help":
-            quiet || bot.chat("![sm ]step [ p(rev) | n(ext) ]");
-            break;
-        case "n":
-        case "next":
-        default:
-            service?.send("NEXT");
-            quiet || bot.chat("stepped");
-            break;
-    }
-}
-function tickSM(time = bot.time.timeOfDay, rate = 20) {
-    if (time % rate !== 0) {
-        return;
-    }
-    console.log("sm tick", rate, time);
-}
-function debugSM(name = getSM()) {
-    if (!name)
-        return;
-    let service = getSM(name, true);
-    if (!service)
-        return;
-    const machine = service.machine;
-    machine.meta.debug = !!!machine.meta.debug;
-    console.info("sm debug", machine.meta, service, machine);
-    cfg.statemachine.quiet || machine.meta.debug && bot.chat("sm debug: " + machine.id);
-}
-function command(message_parts) {
-    const message_parts2 = message_parts.slice(1);
-    switch (message_parts[0]) {
-        case "add":
-            command(["new"].concat(message_parts2));
-            break;
-        case "finish":
-        case "done":
-        case "end":
-            command(["save"].concat(message_parts2));
-            break;
-        case "do":
-        case "load":
-        case "start":
-            command(["run"].concat(message_parts2));
-            break;
-        case "debug":
-            switch (message_parts[1]) {
-                case "sm":
-                case "global":
-                case "meta":
-                    cfg.statemachine.debug = !!!cfg.statemachine.debug;
-                    quiet || bot.chat(`sm debug: ${cfg.statemachine.debug}`);
-                    break;
-            }
-        case "new":
-        case "save":
-        case "run":
-        case "step":
-        case "stop":
-        // temp
-        case "action":
-            switch (message_parts2.length) {
-                case 0:
-                    console.warn(`sm ${message_parts[0]}: no name, using defaults`);
-                case 1:
-                    // FIXME `this` doesn't work always
-                    (this.runSM && this || cfg.plugins.statemachine)[message_parts[0] + "SM"](...message_parts2);
-                    break;
-                default:
-                    if (["action"].includes(message_parts[0])) {
-                        (this.runSM && this || cfg.plugins.statemachine)[message_parts[0] + "SM"](...message_parts2);
-                    }
-                    else {
-                        console.warn(`sm ${message_parts[0]}: more than 1 arg passed`, message_parts2);
-                    }
-                    break;
-            }
-            break;
-        case "undo":
-            break;
-        case "list":
-        case "status":
-            // TODO current/recent, updateRate
-            const { list, running } = cfg.statemachine;
-            console.log("sm list", running, list);
-            quiet || bot.chat(`${Object.keys(running).length} of ${Object.keys(list).length} active: ${Object.keys(running)}`
-                + (message_parts[1] === "all" ? `${Object.keys(list)}` : ''));
-            break;
-        case "quiet":
-            quiet = cfg.statemachine.quiet = !!!cfg.statemachine.quiet;
-            quiet || bot.chat(`sm: ${cfg.statemachine.quiet ? "" : "not "}being quiet`);
-            break;
-        default:
-            // TODO general helper from declarative commands object
-            quiet || bot.chat(`sm help: !sm [new | step| save | run | list | quiet | debug]`);
-            console.warn("sm unknown command", message_parts);
-            break;
-    }
-    return true;
-}
-function load(config) {
-    webserver = cfg.statemachine.webserver = config.statemachine?.webserver || webserver;
-    config.statemachine = cfg.statemachine || {
-        webserver: null,
-        // quiet: true,
-        quiet: false,
-        list: {},
-        running: {},
-        draft: null,
-        recent: null,
-        // debug: null,
-        debug: true,
-        updateRate: updateRate
-    };
-    cfg = config;
-    bot = cfg.bot;
-    // pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder)
-    // mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
-    init(undefined, webserver);
-    updateRate = cfg.statemachine.updateRate || updateRate;
-    bot.on('time', tickSM);
-    // bot.once('time', tickSM, 5)
-    console.log("sm load", cfg.statemachine);
-}
-function unload() {
-    const { list, running } = cfg.statemachine;
-    bot.off('time', tickSM);
-    Object.keys(running).forEach(sm => {
-        stopSM(sm);
-    });
-    // delete cfg.statemachine;
-    cfg.statemachine = null;
-    console.log("sm unload: deleted", cfg.statemachine);
-}
-module.exports = {
-    load, unload, command, init,
-    newSM, saveSM, loadSM, runSM, stopSM, actionSM, stepSM, debugSM
-};
+
+module.exports = { load, unload }

package.json

@@ -30,26 +30,24 @@
   },
   "homepage": "https://github.com/PrismarineJS/prismarine-template#readme",
   "devDependencies": {
-    "@types/node": "^14.14.41",
     "jest": "^26.6.3",
-    "require-self": "^0.2.3",
-    "typescript": "^4.2.4"
+    "require-self": "^0.2.3"
   },
   "dependencies": {
-    "dotenv-packed": "^1.2.2",
-    "minecraft-data": "^2.84.0",
-    "mineflayer": "^3.6.0",
-    "mineflayer-armor-manager": "^1.4.1",
-    "mineflayer-pathfinder": "^1.6.1",
-    "mineflayer-pvp": "^1.0.2",
-    "prismarine-block": "^1.8.0",
-    "prismarine-chat": "^1.0.3",
+    "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",
     "prismarine-entity": "^1.1.0",
-    "prismarine-item": "^1.8.0",
-    "prismarine-nbt": "^1.5.0",
-    "prismarine-recipe": "^1.1.0",
-    "vec3": "^0.1.7",
-    "xstate": "^4.18.0"
+    "prismarine-item": "^1.5.0",
+    "prismarine-nbt": "^1.3",
+    "prismarine-recipe": "^1",
+    "typescript": "^4",
+    "vec3": "^0.1",
+    "dotenv-packed": "^1.2"
   },
   "files": [
     "lib/**/*"