feat(builder): 🚧 add cover plugin for mycellium

Work in progress, based on Trend's code. Everything is hardcoded.

.gitignore

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

.vscode/settings.json

@@ -3,8 +3,6 @@
         "command",
         "mover",
         "sleeper",
-        "informer",
+        "informer"
-        "statemachine",
-        "builder"
     ]
 }

lib/index.js

@@ -104,7 +104,7 @@ bot.once("spawn", () => {
         mover: require('./plugins/mover'),
         guard: require('./plugins/guard'),
         // miner: require('./plugins/miner.js'),
-        statemachine: require('./plugins/statemachine'),
+        // statemachine: require('./plugins/statemachine'),
     }
 
     cfg.plugins = plugins

lib/plugins/command.js

@@ -404,16 +404,6 @@ function command(username, message) {
                             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 "location":
                     // TODO put in /lib/location
                     switch (message_parts[1]) {

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(function (err) {
-                bot.consume().catch(error => {
+                if (err) {
-                    if (error.message === "Food is full") {
+                    console.error(err)
-                        console.warn(error, best_food)
-                    } else {
-                        return callback({ error, best_food })
-                    }
-                }).finally(() => {
                     isEating = false
                     bot.emit('eat_stop')
-                })
+                    return callback(err)
-            } catch { }
+                } else {
-            if (bot.food !== 20) eat(callback)
+                    isEating = false
+                    bot.emit('eat_stop')
+                    callback(null)
+                    if (!bot.food === 20) eat(callbackHandle)
+                }
+            })
         }
     })
 }
@@ -72,7 +76,7 @@ function checkFood() {
                 // TODO implement better idle state
             ) || true // idle most likely
         ) {
-            eat()
+            eat(callbackHandle)
         }
     }
 }

lib/plugins/mycellium.js

@@ -0,0 +1,217 @@
+
+// const mineflayer = require('mineflayer')
+// let pathfinder
+// const { pathfinder, Movements, goals } = require('mineflayer-pathfinder')
+const { Vec3 } = require('vec3')
+// const { GoalFollow, GoalNear } = goals
+let GoalFollow, GoalNear
+// const mcData = require('minecraft-data')('1.16.5')
+let mcData
+
+// let bot = mineflayer.createBot()
+let bot
+let cfg = { bot: null }
+let timer
+let movements
+
+/* let mcData
+bot.once('spawn', () => {
+ mcData = require('minecraft-data')(bot.version)
+}) */
+
+function stopCovering(quiet = cfg.quiet, resetGoal = true) {  // This is a function to stop the cover() loop when called
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    if (resetGoal) bot.pathfinder.setGoal(null)
+    bot.stopDigging()
+    quiet || bot.chat("stopped covering")
+}
+
+function init() {
+    const { Movements, goals } = require('mineflayer-pathfinder')
+    GoalFollow = goals.GoalFollow
+    GoalNear = goals.GoalNear
+    movements = new Movements(bot, mcData)
+    movements.canDig = true // Lets the bot dig
+    bot.pathfinder.setMovements(movements)
+
+    console.info("mycelium start")
+    stopCovering(true)
+    bot.waitForChunksToLoad(cover)
+}
+
+function cover(timeInt = 1000) {
+    if (!Number.isSafeInteger(timeInt)) {
+        console.log("cover int maybe goal?", timeInt)
+        switch (timeInt.message) {
+            case "No path to the goal!":
+                console.info("Cover: can't reach")
+                cfg.quiet || bot.chat("can't reach")
+                break;
+
+            default:
+                break;
+        }
+        if (timeInt) {
+            timeInt = 5000
+        }
+    } else if (timeInt < 300) {
+        timeInt = 1000
+    }
+    const wool = "white_wool"
+    const wool_item = mcData.itemsByName[wool]
+    const inventoryWool = bot.inventory.findInventoryItem(wool_item.id)
+    // console.info(wool_item.id, inventoryWool)
+    // if (!inventoryWool) return
+    // bot.loadPlugin(pathfinder)
+
+    const myceliumClean = bot.findBlock({ // Const that is a brown_mushroom
+        maxDistance: 6,
+        matching: (block) => {
+            // First check the type
+            // lol
+            // const { brown_mushroom, red_mushroom, white_wool } = mcData.blocksByName
+            // if ([brown_mushroom.id, red_mushroom.id, white_wool.id].includes(block?.type)) {
+            const { brown_mushroom, red_mushroom, } = mcData.blocksByName
+            if ([brown_mushroom.id, red_mushroom.id,].includes(block?.type)) {
+                // If position is defined, you can refine the search
+                if (block.position) {
+                    const blockBelow = bot.blockAt(block.position.offset(0, -1, 0))
+                    return blockBelow?.type === mcData.blocksByName.mycelium.id || blockBelow?.type === mcData.blocksByName.spruce_fence.id // Makes sure there is mycelium below
+                }
+                return true // otherwise return always true (there is water in the section so it should be checked)
+            }
+            return false
+        }
+    })
+
+    function findMycelium(dist = 5) {
+        return bot.findBlock({
+            maxDistance: dist,
+            matching: (block) => {
+                // First check the type
+                if (block?.type === mcData.blocksByName.mycelium.id) { // Const that is a mycelium block
+                    // If position is defined, you can refine the search
+                    if (block.position) {
+                        const blockAbove = bot.blockAt(block.position.offset(0, 1, 0))
+                        return !blockAbove || blockAbove?.type === mcData.blocksByName.air.id // Makes sure there is nothing above
+                    }
+                    return true // otherwise return always true (there is water in the section so it should be checked)
+                }
+                return false
+            }
+        })
+    }
+    let mycelium = findMycelium()
+
+    if (myceliumClean) {
+        // bot.dig(myceliumClean, true)
+        bot.dig(myceliumClean)
+    }
+
+    if (mycelium) {
+        timeInt = 500
+        if (bot.heldItem?.type !== wool_item.id) { // Equips wool if not already
+            if (!inventoryWool || inventoryWool.count < 10) { // Checks if there is less than 10 wool in the bots inventory
+                timeInt = 5000
+                console.warn("no wool")
+                // const chestLocation = new Vec3(10614, 70, 5350) // Sets chest location
+                const chestLocation = bot.findBlock({
+                    maxDistance: 100,
+                    matching: block => block && block.type === mcData.blocksByName.chest.id
+                })?.position // Sets chest location
+                const chestGoal = new GoalNear(chestLocation.x, chestLocation.y, chestLocation.z, 6) // Sets goal to chest location
+                return bot.pathfinder.goto(chestGoal, () => { // Run code below when it gets to the chest
+                    bot.lookAt(chestLocation, true) // Looks at chest
+                    const chest = bot.openChest(bot.blockAt(chestLocation)) // Sets const to for opening chest
+                    chest.once('open', (err) => { // Opens chest
+                        if (err) {
+                            return console.error('Chest error', err)
+                        }
+                        const chest_item = chest.items().filter(item => item.type === wool_item.id)
+                        console.info(chest, chest_item)
+                        if (chest_item.length > 0) { // Checks that there is stuff in chest
+                            try {
+                                // Pulls out a chest (27 stack) of wool
+                                // chest.withdraw(chest_item[0].type, null, 64 * 27)
+                                chest.withdraw(chest_item[0].type, null, 64 * 3)
+                            } catch (error) {
+                                console.error('Chest withdraw error', error)
+                            }
+                            bot.once("close", cover)
+                        } else {
+                            console.log('Chest dont have', wool_item)
+                            cfg.quiet || bot.chat(`Not enough ${wool} in chest`)
+                            stopCovering()
+                        }
+                        setTimeout(chest.close, timeInt)
+                    })
+                })
+            } else {
+                bot.equip(wool_item.id, "hand")
+            }
+        } else {
+            const pos = mycelium.position
+            bot.lookAt(pos, true)
+            // let tryCount = 0
+            const flooredPos = bot.entity.position.floored()
+            if (flooredPos.offset(0, 1, 0).distanceTo(pos) <= 2) {
+                bot.setControlState('jump', true)
+                if (bot.entity.position.y > mycelium.position.y) {
+                    bot.placeBlock(mycelium, new Vec3(0, 1, 0), (err) => {
+                        setTimeout(bot.setControlState, 2000, 'jump', false)
+                        if (err) {
+                            console.error('Place (jumped)', err)
+                        }
+                    })
+                }
+            } else {
+                bot.placeBlock(mycelium, new Vec3(0, 1, 0), (err) => {
+                    if (err) {
+                        if (err.message !== `No block has been placed : the block is still ${wool}`) {
+                            return console.error('Place (normal)', err)
+                        } else {
+                            return
+                        }
+                    }
+                })
+            }
+        }
+    } else {
+        mycelium = findMycelium(100)
+        if (mycelium) {
+            const pos = mycelium.position
+            const goal = new GoalNear(pos.x, pos.y, pos.z, 3)
+            stopCovering(true)
+            timeInt = 2000
+            return bot.pathfinder.goto(goal, cover)
+        } else {
+            stopCovering(true)
+            return cfg.quiet || bot.chat("no uncovered mycelium nearby")
+        }
+    }
+
+    timer = setTimeout(cover, timeInt, timeInt)
+}
+
+function command(params) {
+    stopCovering(true)
+    cover()
+}
+
+const load = (config) => {
+    cfg = config
+    bot = cfg.bot
+    mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
+
+    pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder)
+    init()
+}
+
+const unload = () => {
+    stopCovering(true)
+}
+
+module.exports = { load, unload, command, cover, stopCovering }

lib/plugins/statemachine.js

@@ -1,476 +1,115 @@
-// import { createMachine, interpret, InterpreterStatus } from "xstate";
+// Load your dependency plugins.
-const { createMachine, interpret, InterpreterStatus } = require('xstate');
+
-// import { access, mkdir, writeFile, readFile } from "fs";
+const {pathfinder} = require('mineflayer-pathfinder')
-const { access, mkdir, writeFile, readFile } = require('fs');
+// bot.loadPlugin(require('prismarine-viewer').mineflayer)
-const v = require('vec3'); // for look dummy action, maybe not needed in future
+// const mineflayerViewer = require('prismarine-viewer').mineflayer
-// ANGRAM_PREFIX='MINECRAFT'
+
-const { MINECRAFT_DATA_FOLDER } = process.env || require("dotenv-packed").parseEnv().parsed;
+// Import required behaviors.
-const storage_dir = MINECRAFT_DATA_FOLDER || './data/' + "/sm/";
+const {
-// import { createBot } from "mineflayer"
+    StateTransition,
-// let { pathfinder, Movements, goals } = require('mineflayer-pathfinder')
+    BotStateMachine,
-// let cfg
+    EntityFilters,
-// let bot = createBot({ username: 'statebot' })
+    BehaviorFollowEntity,
-let bot;
+    BehaviorLookAtEntity,
-let quiet;
+    BehaviorGetClosestEntity,
-let updateRate = 20;
+    NestedStateMachine,
-const machines = {
+    BehaviorIdle,
-    list: {},
+    StateMachineWebserver,
-    running: {},
+} = require("mineflayer-statemachine");
-};
+
-let webserver;
+// TODO chat
-let cfg = {
+
-    statemachine: {
+
-        webserver: null,
+
-        // quiet: true,
+// wait for our bot to login.
-        quiet: quiet,
+function statemachineInit() {
-        list: {},
+    cfg.botAddress = new RegExp(`^${bot.username} (!.+)`)
-        running: {},
+    // This targets object is used to pass data between different states. It can be left empty.
-        draft: null,
+    const targets = new Object();
-        recent: null,
+
-        // debug: null,
+    // Create our states
-        debug: true,
+    const getClosestPlayer = new BehaviorGetClosestEntity(
-        updateRate: updateRate
+        bot, targets, entity => EntityFilters().PlayersOnly(entity) && bot.entity.position.distanceTo(entity.position) <= 50 ); // && a.username !== bot.username);
-    }
+    const followPlayer = new BehaviorFollowEntity(bot, targets);
-    // FIXME temp variables to satisfy typescript autocomplete
+    const lookAtPlayer = new BehaviorLookAtEntity(bot, targets);
-    // , quiet: null
+    const stay = new BehaviorIdle();
-    ,
+
-    bot: bot,
+    // Create our transitions
-    plugins: { statemachine: null }
+    const transitions = [
-};
+
-// Edit your machine(s) here
+        // We want to start following the player immediately after finding them.
-function init(smName = "dummy", webserver) {
+        // Since getClosestPlayer finishes instantly, shouldTransition() should always return true.
-    access(storage_dir, err => {
+        new StateTransition({
-        if (err?.code === 'ENOENT') {
+            parent: getClosestPlayer,
-            mkdir(storage_dir, e => e && console.warn("sm init: create dir", e));
+            child: followPlayer,
-        }
+            onTransition: (quiet) => quiet || bot.chat(`Hi ${targets.entity.username}!`),
-        else if (err) {
+            shouldTransition: () => bot.entity.position.distanceTo(targets.entity.position) <= 50,
-            console.warn("sm init: create dir", err);
+            // shouldTransition: () => getClosestPlayer.distanceToTarget() < 100 || console.info("player too far!") && false,
-        }
+        }),
-    });
+
-    // const machine = newSM(smName)
+        // If the distance to the player is less than two blocks, switch from the followPlayer
-    // machine.states.idle.on.TOGGLE = "start"
+        // state to the lookAtPlayer state.
-    // machine.states.start.on.TOGGLE = "idle"
+        new StateTransition({
-    const machine = createMachine({
+            parent: followPlayer,
-        id: smName,
+            child: lookAtPlayer,
-        initial: "idle",
+            // onTransition: () => console.log(targets),
-        states: {
+            shouldTransition: () => followPlayer.distanceToTarget() < 2,
-            idle: {
+        }),
-                on: { TOGGLE: "start", NEXT: "start", PREV: "look", STOP: "finish" }
+
-            },
+        // If the distance to the player is more than two blocks, switch from the lookAtPlayer
-            start: {
+        // state to the followPlayer state.
-                on: { TOGGLE: "look", NEXT: "look", PREV: "idle" },
+        new StateTransition({
-                entry: 'lookAtPlayerOnce',
+            parent: lookAtPlayer,
-            },
+            child: followPlayer,
-            look: {
+            shouldTransition: () => lookAtPlayer.distanceToTarget() >= 5,
-                on: { TOGGLE: "idle", NEXT: "idle", PREV: "start" },
+        }),
-                // entry: ['look', 'blah']
+        new StateTransition({
-                // entry: 'lookAtPlayerOnce',
+            parent: lookAtPlayer,
-                activities: 'lookAtPlayer',
+            child: stay,
-                meta: { debug: true }
+            onTransition: () => bot.chat("ok, staying"),
-            },
+            // shouldTransition: () => true,
-            finish: {
+        }),
-                type: 'final'
+        new StateTransition({
-            },
+            parent: stay,
-        },
+            child: getClosestPlayer,
-        on: { START: '.start', STOP: '.idle' },
+            // shouldTransition: () => Math.random() > 0.01,
-        meta: { debug: true },
+            // shouldTransition: () => Math.random() > 0.1 && getClosestPlayer.distanceToTarget() < 2,
-        context: { player: null, rate: updateRate },
+        }),
-    }, {
+    ];
-        actions: {
+
-            // action implementation
+    // Now we just wrap our transition list in a nested state machine layer. We want the bot
-            lookAtPlayerOnce: (context, event) => {
+    // to start on the getClosestPlayer state, so we'll specify that here.
-                const player = context?.player || bot.nearestEntity(entity => entity.type === 'player');
+    const rootLayer = new NestedStateMachine(transitions, getClosestPlayer, stay);
-                if (player.position || player.entity) {
+
-                    context.player = player;
+    // We can start our state machine simply by creating a new instance.
-                    bot.lookAt((new v.Vec3(0, 1, 0)).add((player.entity || player).position));
+    cfg.stateMachines.follow = new BotStateMachine(bot, rootLayer);
-                }
+    const webserver = new StateMachineWebserver(bot, cfg.stateMachines.follow);
-            }
+    webserver.startServer();
-        },
+
-        activities: {
+    // mineflayerViewer(bot, { port: 3000 })
-            lookAtPlayer: (context, event) => {
+    // const path = [bot.entity.position.clone()]
-                const player = context?.player || bot.nearestEntity(entity => entity.type === 'player');
+    // bot.on('move', () => {
-                // TODO  check every event?
+    //     if (path[path.length - 1].distanceTo(bot.entity.position) > 1) {
-                if (player.position || player.entity) {
+    //         path.push(bot.entity.position.clone())
-                    context.player = player;
+    //         bot.viewer.drawLine('path', path)
-                    function looks() {
+    //     }
-                        bot.lookAt((new v.Vec3(0, 1, 0)).add((player.entity || player).position));
+    // })
-                    }
+}
-                    bot.on("time", looks);
+
-                    return () => bot.off("time", looks);
+const load = (config) => {
-                }
+    cfg = config
-            }
+    bot = cfg.bot
-        },
+    // cfg.inventory = {
-        delays: {
+    //     auto: true,
-            /* ... */
+    //     quiet: false
-        },
+    // }
-        guards: {
+    // bot.on('chat', inventory)
-            /* ... */
+    bot.loadPlugin(pathfinder)
-        },
+    // statemachineInit()
-        services: {
+}
-            /* ... */
+
-        }
+const unload = () => {
-    });
+    // bot.off('chat', inventory)
-    console.log("sm init: machine", machine);
+}
-    const service = runSM(saveSM(machine));
+
-    if (service?.send) {
+module.exports = { load, unload }
-        setTimeout(service.send, 200, "TOGGLE");
-        // setTimeout(service.send, 400, "TOGGLE")
-    }
-    else {
-        console.warn("sm init: service", service);
-    }
-}
-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;
-}
-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;
-}
-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();
-    // // TODO check if idle state is different (maybe?)
-    console.log("sm run", service.state.value === machine.initialState.value, service.state);
-    console.log("sm run", service.state !== machine.initialState, machine.initialState);
-    // 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.toLowerCase());
-}
-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
-};

package.json

@@ -31,24 +31,23 @@
   "homepage": "https://github.com/PrismarineJS/prismarine-template#readme",
   "devDependencies": {
     "jest": "^26.6.3",
-    "require-self": "^0.2.3",
+    "require-self": "^0.2.3"
-    "typescript": "^4.2.3"
   },
   "dependencies": {
     "dotenv-packed": "^1.2.1",
-    "minecraft-data": "^2.80.0",
+    "minecraft-data": "^2.73.1",
-    "mineflayer": "^3.4.0",
+    "mineflayer": "^2.40.1",
     "mineflayer-armor-manager": "^1.4.0",
-    "mineflayer-pathfinder": "^1.6.1",
+    "mineflayer-pathfinder": "^1.3.6",
     "mineflayer-pvp": "^1.0.2",
-    "prismarine-block": "^1.8.0",
+    "prismarine-block": "^1.7.3",
     "prismarine-chat": "^1.0.3",
     "prismarine-entity": "^1.1.0",
-    "prismarine-item": "^1.8.0",
+    "prismarine-item": "^1.5.0",
-    "prismarine-nbt": "^1.5.0",
+    "prismarine-nbt": "^1.4.0",
     "prismarine-recipe": "^1.1.0",
-    "vec3": "^0.1.7",
+    "typescript": "^4.1.3",
-    "xstate": "^4.17.0"
+    "vec3": "^0.1.7"
   },
   "files": [
     "lib/**/*"