feat(statemachine): 🚧 first draft of new xstate based statemachine implementation

Replaces the old statemachine.
Done so far:
- Basic command interface
- Machine saving and loading
- Sample dummy machine
master
jay 3 years ago
parent 3f3ebbae10
commit 33c4233223
  1. 1
      .gitignore
  2. 2
      lib/index.js
  3. 10
      lib/plugins/command.js
  4. 591
      lib/plugins/statemachine.js

1
.gitignore vendored

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

@ -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

@ -404,6 +404,16 @@ 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]) {

@ -1,115 +1,476 @@
// 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)
// }
// })
}
const load = (config) => {
cfg = config
bot = cfg.bot
// cfg.inventory = {
// auto: true,
// quiet: false
// }
// bot.on('chat', inventory)
bot.loadPlugin(pathfinder)
// statemachineInit()
}
const unload = () => {
// bot.off('chat', inventory)
}
module.exports = { load, unload }
// 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');
const v = require('vec3'); // for look dummy action, maybe not needed in future
// 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 || bot.nearestEntity(entity => entity.type === 'player');
if (player.position || player.entity) {
context.player = player;
bot.lookAt((new v.Vec3(0, 1, 0)).add((player.entity || player).position));
}
}
},
activities: {
lookAtPlayer: (context, event) => {
const player = context?.player || bot.nearestEntity(entity => entity.type === 'player');
// TODO check every event?
if (player.position || player.entity) {
context.player = player;
function looks() {
bot.lookAt((new v.Vec3(0, 1, 0)).add((player.entity || player).position));
}
bot.on("time", looks);
return () => bot.off("time", looks);
}
}
},
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);
}
}
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
};
Loading…
Cancel
Save