jay/angram
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: jay:72c4622091639edd84d2c0fae14a736ba17fb759
Branches Tags
jay:master
jay:cover
jay:nogameplay
..
compare: jay:aded1e4193a9a49a2a11a9be64ea5cdbf3cf98e4
Branches Tags
jay:master
jay:cover
jay:nogameplay

3 Commits
72c4622091 ... aded1e4193

Author SHA1 Message Date
jay
aded1e4193 style: 🎨 fix crlf -> lf for real this time, using .gitattributes 
Add a .gitattributes file to permanentyl fix crlf issues.

For explanantion:
https://adaptivepatchwork.com/2012/03/01/mind-the-end-of-your-line/#the-new-system
 2021-03-24 15:07:45 +05:00
jay
60394e38eb refactor: ♻️ replace add with vec3.offset 
This avoids having to import and creat a `new vec3.v()`
 2021-03-24 00:40:54 +05:00
jay
22490f7ec1 fix(command): 🐛 fix bot address regex returning undefined 
Waits till spawn to make sure `bot.username` is definitely initialized
 2021-03-23 23:10:58 +05:00
6 changed files with 525 additions and 513 deletions
Show Stats Expand all files Collapse all files

16
.gitattributes vendored Normal file
View File

@ -0,0 +1,16 @@
# 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

60
.gitignore vendored
View File

@ -1,31 +1,31 @@
# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
# dependencies # dependencies
/node_modules /node_modules
/.pnp /.pnp
.pnp.js .pnp.js
# testing # testing
/coverage /coverage
# production # production
/build /build
/data /data
# misc # misc
.DS_Store .DS_Store
.env .env
.env.local .env.local
.env.development.local .env.development.local
.env.test.local .env.test.local
.env.production.local .env.production.local
/lib/**/*.old /lib/**/*.old
/lib/**/*.bak /lib/**/*.bak
npm-debug.log* npm-debug.log*
yarn-debug.log* yarn-debug.log*
yarn-error.log* yarn-error.log*
# Editor # Editor
*.swp *.swp
*.swo *.swo

2
lib/index.js
View File

@ -88,7 +88,6 @@ fs.watch('./lib/plugins', reloadplugin)
cfg.bot = bot cfg.bot = bot
// TODO better name, or switch to array // TODO better name, or switch to array
cfg.botAddressPrefix = '!' cfg.botAddressPrefix = '!'
cfg.botAddressRegex = new RegExp(`^${bot.username} (${cfg.botAddressPrefix}.+)`)
cfg.quiet = true cfg.quiet = true
@ -110,6 +109,7 @@ bot.once("spawn", () => {
} }
cfg.plugins = plugins cfg.plugins = plugins
cfg.botAddressRegex = new RegExp(`^${bot.username} (${cfg.botAddressPrefix}.+)`)
for (const plugin of Object.values(plugins)) { for (const plugin of Object.values(plugins)) {
try { try {

9
lib/plugins/command.js
View File

@ -30,11 +30,10 @@ const events = {
whisper: function command_whisper(username, message) { whisper: function command_whisper(username, message) {
if ([bot.username, "me"].includes(username)) return if ([bot.username, "me"].includes(username)) return
if (/^gossip/.test(message)) return if (/^gossip/.test(message)) return
// if (/^!/.test(message) && username === cfg.admin){
if (username === cfg.admin) { if (username === cfg.admin) {
message = message.replace("\\", "@") message = message.replace("\\", "@")
console.info("whispered command", message) console.info("whispered command", message)
if (/^!/.test(message)) { if (message.startsWith(cfg.botAddressPrefix)) {
command(username, message) command(username, message)
} else { } else {
bot.chat(message) bot.chat(message)
@ -297,7 +296,7 @@ function command(username, message) {
switch (message_parts[1]) { switch (message_parts[1]) {
case "me": case "me":
if (player) { if (player) {
bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position)) bot.lookAt(player.position.offset(0, 1, 0))
} else { } else {
cfg.quiet || bot.chat("can't see you") cfg.quiet || bot.chat("can't see you")
} }
@ -314,7 +313,7 @@ function command(username, message) {
break break
default: default:
const aPlayer = bot.players[message_parts[2]] ? bot.players[message_parts[2]].entity : null const aPlayer = bot.players[message_parts[2]] ? bot.players[message_parts[2]].entity : null
if (aPlayer) bot.lookAt((new v.Vec3(0, 1, 0)).add(aPlayer.position)) if (aPlayer) bot.lookAt(aPlayer.position.offset(0, 1, 0))
break; break;
} }
break break
@ -475,7 +474,7 @@ function command(username, message) {
case "howdy": case "howdy":
case "heyo": case "heyo":
case "yo": case "yo":
if (player) bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position)) if (player) bot.lookAt(player.position.offset(0, 1, 0))
// TODO sneak // TODO sneak
// function swingArm() { // function swingArm() {

2
lib/plugins/guard.js
View File

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

949
lib/plugins/statemachine.js
View File

@ -1,476 +1,475 @@
// import { createMachine, interpret, InterpreterStatus } from "xstate"; // import { createMachine, interpret, InterpreterStatus } from "xstate";
const { createMachine, interpret, InterpreterStatus } = require('xstate'); const { createMachine, interpret, InterpreterStatus } = require('xstate');
// import { access, mkdir, writeFile, readFile } from "fs"; // import { access, mkdir, writeFile, readFile } from "fs";
const { access, mkdir, writeFile, readFile } = require('fs'); const { access, mkdir, writeFile, readFile } = require('fs');
const v = require('vec3'); // for look dummy action, maybe not needed in future // ANGRAM_PREFIX='MINECRAFT'
// ANGRAM_PREFIX='MINECRAFT' const { MINECRAFT_DATA_FOLDER } = process.env || require("dotenv-packed").parseEnv().parsed;
const { MINECRAFT_DATA_FOLDER } = process.env || require("dotenv-packed").parseEnv().parsed; const storage_dir = MINECRAFT_DATA_FOLDER || './data/' + "/sm/";
const storage_dir = MINECRAFT_DATA_FOLDER || './data/' + "/sm/"; // import { createBot } from "mineflayer"
// import { createBot } from "mineflayer" // let { pathfinder, Movements, goals } = require('mineflayer-pathfinder')
// let { pathfinder, Movements, goals } = require('mineflayer-pathfinder') // let cfg
// let cfg // let bot = createBot({ username: 'statebot' })
// let bot = createBot({ username: 'statebot' }) let bot;
let bot; let quiet;
let quiet; let updateRate = 20;
let updateRate = 20; const machines = {
const machines = { list: {},
list: {}, running: {},
running: {}, };
}; let webserver;
let webserver; let cfg = {
let cfg = { statemachine: {
statemachine: { webserver: null,
webserver: null, // quiet: true,
// quiet: true, quiet: quiet,
quiet: quiet, list: {},
list: {}, running: {},
running: {}, draft: null,
draft: null, recent: null,
recent: null, // debug: null,
// debug: null, debug: true,
debug: true, updateRate: updateRate
updateRate: updateRate }
} // FIXME temp variables to satisfy typescript autocomplete
// FIXME temp variables to satisfy typescript autocomplete // , quiet: null
// , quiet: null ,
, bot: bot,
bot: bot, plugins: { statemachine: null }
plugins: { statemachine: null } };
}; // Edit your machine(s) here
// Edit your machine(s) here function init(smName = "dummy", webserver) {
function init(smName = "dummy", webserver) { access(storage_dir, err => {
access(storage_dir, err => { if (err?.code === 'ENOENT') {
if (err?.code === 'ENOENT') { mkdir(storage_dir, e => e && console.warn("sm init: create dir", e));
mkdir(storage_dir, e => e && console.warn("sm init: create dir", e)); }
} else if (err) {
else if (err) { console.warn("sm init: create dir", err);
console.warn("sm init: create dir", err); }
} });
}); // const machine = newSM(smName)
// const machine = newSM(smName) // machine.states.idle.on.TOGGLE = "start"
// machine.states.idle.on.TOGGLE = "start" // machine.states.start.on.TOGGLE = "idle"
// machine.states.start.on.TOGGLE = "idle" const machine = createMachine({
const machine = createMachine({ id: smName,
id: smName, initial: "idle",
initial: "idle", states: {
states: { idle: {
idle: { on: { TOGGLE: "start", NEXT: "start", PREV: "look", STOP: "finish" }
on: { TOGGLE: "start", NEXT: "start", PREV: "look", STOP: "finish" } },
}, start: {
start: { on: { TOGGLE: "look", NEXT: "look", PREV: "idle" },
on: { TOGGLE: "look", NEXT: "look", PREV: "idle" }, entry: 'lookAtPlayerOnce',
entry: 'lookAtPlayerOnce', },
}, look: {
look: { on: { TOGGLE: "idle", NEXT: "idle", PREV: "start" },
on: { TOGGLE: "idle", NEXT: "idle", PREV: "start" }, // entry: ['look', 'blah']
// entry: ['look', 'blah'] // entry: 'lookAtPlayerOnce',
// entry: 'lookAtPlayerOnce', activities: 'lookAtPlayer',
activities: 'lookAtPlayer', meta: { debug: true }
meta: { debug: true } },
}, finish: {
finish: { type: 'final'
type: 'final' },
}, },
}, on: { START: '.start', STOP: '.idle' },
on: { START: '.start', STOP: '.idle' }, meta: { debug: true },
meta: { debug: true }, context: { player: null, rate: updateRate },
context: { player: null, rate: updateRate }, }, {
}, { actions: {
actions: { // action implementation
// action implementation lookAtPlayerOnce: (context, event) => {
lookAtPlayerOnce: (context, event) => { const player = context?.player || bot.nearestEntity(entity => entity.type === 'player');
const player = context?.player || bot.nearestEntity(entity => entity.type === 'player'); if (player.position || player.entity) {
if (player.position || player.entity) { context.player = player;
context.player = player; bot.lookAt((player.entity || player).position.offset(0, 1, 0));
bot.lookAt((new v.Vec3(0, 1, 0)).add((player.entity || player).position)); }
} }
} },
}, activities: {
activities: { lookAtPlayer: (context, event) => {
lookAtPlayer: (context, event) => { const player = context?.player || bot.nearestEntity(entity => entity.type === 'player');
const player = context?.player || bot.nearestEntity(entity => entity.type === 'player'); // TODO check every event?
// TODO check every event? if (player.position || player.entity) {
if (player.position || player.entity) { context.player = player;
context.player = player; function looks() {
function looks() { bot.lookAt((player.entity || player).position.offset(0, 1, 0));
bot.lookAt((new v.Vec3(0, 1, 0)).add((player.entity || player).position)); }
} bot.on("time", looks);
bot.on("time", looks); return () => bot.off("time", looks);
return () => bot.off("time", looks); }
} }
} },
}, delays: {
delays: { /* ... */
/* ... */ },
}, guards: {
guards: { /* ... */
/* ... */ },
}, services: {
services: { /* ... */
/* ... */ }
} });
}); console.log("sm init: machine", machine);
console.log("sm init: machine", machine); const service = runSM(saveSM(machine));
const service = runSM(saveSM(machine)); if (service?.send) {
if (service?.send) { setTimeout(service.send, 200, "TOGGLE");
setTimeout(service.send, 200, "TOGGLE"); // setTimeout(service.send, 400, "TOGGLE")
// setTimeout(service.send, 400, "TOGGLE") }
} else {
else { console.warn("sm init: service", service);
console.warn("sm init: service", service); }
} }
} function newSM(smName = "sm_" + Object.keys(cfg.statemachine.list).length) {
function newSM(smName = "sm_" + Object.keys(cfg.statemachine.list).length) { smName = smName.replace(/\s+/, '_');
smName = smName.replace(/\s+/, '_'); if (cfg.statemachine.list[smName]) {
if (cfg.statemachine.list[smName]) { console.warn("sm exists", smName);
console.warn("sm exists", smName); quiet || bot.chat(`sm ${smName} already exists, edit or use another name instead`);
quiet || bot.chat(`sm ${smName} already exists, edit or use another name instead`); return;
return; }
} const machine = createMachine({
const machine = createMachine({ id: smName,
id: smName, initial: "start",
initial: "start", // TODO use history states for PAUSE and RESUME
// TODO use history states for PAUSE and RESUME states: { idle: { on: { START: "start" } }, start: { on: { STOP: "idle" } } }
states: { idle: { on: { START: "start" } }, start: { on: { STOP: "idle" } } } });
}); cfg.statemachine.draft = machine;
cfg.statemachine.draft = machine; return machine;
return machine; }
} function saveSM(machine = cfg.statemachine.draft) {
function saveSM(machine = cfg.statemachine.draft) { if (!machine?.id) {
if (!machine?.id) { console.warn("sm save: invalid", machine);
console.warn("sm save: invalid", machine); quiet || bot.chat("sm: couldn't save, invalid");
quiet || bot.chat("sm: couldn't save, invalid"); return;
return; }
} // TODO do tests and validation
// TODO do tests and validation // 1. ensure default states [start, idle]
// 1. ensure default states [start, idle] // 2. ensure closed cycle from start to idle
// 2. ensure closed cycle from start to idle cfg.statemachine.list[machine.id] = machine;
cfg.statemachine.list[machine.id] = machine; if (machine.id === cfg.statemachine.draft?.id) {
if (machine.id === cfg.statemachine.draft?.id) { cfg.statemachine.draft = null;
cfg.statemachine.draft = null; }
} writeFile(
writeFile( // TODO
// TODO // `${storage_dir}/${player}/${machine.id}.json`
// `${storage_dir}/${player}/${machine.id}.json` `${storage_dir}/${machine.id}.json`,
`${storage_dir}/${machine.id}.json`, // TODO decide which data to store
// TODO decide which data to store // https://xstate.js.org/docs/guides/states.html#persisting-state
// https://xstate.js.org/docs/guides/states.html#persisting-state // JSON.stringify(machine.toJSON),
// JSON.stringify(machine.toJSON), // JSON.stringify(machine.states.toJSON), // + activities, delays, etc
// 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));
JSON.stringify({ config: machine.config, context: machine.context }), e => e && console.log("sm load sm: write file", e)); // return run ? runSM(machine) : machine
// return run ? runSM(machine) : machine return machine;
return machine; }
} function loadSM(name, run = true) {
function loadSM(name, run = true) { //: StateMachine<any, any, any> {
//: StateMachine<any, any, any> { readFile(
readFile( // readFileSync(
// readFileSync( // TODO
// TODO // `${storage_dir}/${player}/${machine.id}.json`
// `${storage_dir}/${player}/${machine.id}.json` `${storage_dir}/${name}.json`, afterRead
`${storage_dir}/${name}.json`, afterRead // JSON.stringify(machine.toJSON),
// JSON.stringify(machine.toJSON), );
); function afterRead(err, jsonString) {
function afterRead(err, jsonString) { if (err) {
if (err) { console.warn("sm load sm: read file", err);
console.warn("sm load sm: read file", err); return;
return; }
} else {
else { const machine = createMachine(JSON.parse(jsonString).config);
const machine = createMachine(JSON.parse(jsonString).config); // TODO do tests and validation
// TODO do tests and validation // 1. ensure default states [start, idle]
// 1. ensure default states [start, idle] // 2. ensure closed cycle from start to idle
// 2. ensure closed cycle from start to idle cfg.statemachine.list[machine.id] = machine;
cfg.statemachine.list[machine.id] = machine; if (machine.id === cfg.statemachine.draft?.id) {
if (machine.id === cfg.statemachine.draft?.id) { cfg.statemachine.draft = machine;
cfg.statemachine.draft = machine; }
} if (run) {
if (run) { runSM(machine);
runSM(machine); }
} }
} }
} // return run ? runSM(machine) : machine
// return run ? runSM(machine) : machine // return machine
// return machine }
} // function isInterpreter(SMorService: StateMachine<any, any, any> | Interpreter<any>): SMorService is Interpreter<any> {
// function isInterpreter(SMorService: StateMachine<any, any, any> | Interpreter<any>): SMorService is Interpreter<any> { // return (SMorService as Interpreter<any>).start !== undefined;
// return (SMorService as Interpreter<any>).start !== undefined; // }
// } function getSM(name = cfg.statemachine.draft || cfg.statemachine.recent, asService = false, quiet = false) {
function getSM(name = cfg.statemachine.draft || cfg.statemachine.recent, asService = false, quiet = false) { const machine = typeof name === "string" ? cfg.statemachine.list[name]
const machine = typeof name === "string" ? cfg.statemachine.list[name] : name;
: name; if (!machine) {
if (!machine) { console.warn("sm get: doesn't exist", name);
console.warn("sm get: doesn't exist", name); cfg.statemachine.quiet || bot.chat(`sm ${name} doesn't exist`);
cfg.statemachine.quiet || bot.chat(`sm ${name} doesn't exist`); return;
return; }
} if (asService) {
if (asService) { const service = cfg.statemachine.running[machine?.id];
const service = cfg.statemachine.running[machine?.id]; if (!service) {
if (!service) { quiet || console.warn("sm get: already stopped", machine);
quiet || console.warn("sm get: already stopped", machine); quiet || cfg.statemachine.quiet || bot.chat(`sm ${machine?.id} isn't running`);
quiet || cfg.statemachine.quiet || bot.chat(`sm ${machine?.id} isn't running`); return interpret(machine);
return interpret(machine); }
} return service;
return service; }
} else {
else { // return machine.machine ? machine.machine : machine
// return machine.machine ? machine.machine : machine return machine;
return machine; }
} }
} function runSM(name = getSM(undefined, undefined, true), player // or supervisor?
function runSM(name = getSM(undefined, undefined, true), player // or supervisor? , restart = false) {
, restart = false) { if (!name)
if (!name) return;
return; const service = getSM(name, true, true);
const service = getSM(name, true, true); if (!service)
if (!service) return;
return; const machine = service.machine;
const machine = service.machine; if (!machine)
if (!machine) return;
return; switch (service.status) {
switch (service.status) { case InterpreterStatus.Running:
case InterpreterStatus.Running: if (!restart) {
if (!restart) { console.warn("sm run: already running", service.id);
console.warn("sm run: already running", service.id); quiet || bot.chat(`sm ${service.id} already running`);
quiet || bot.chat(`sm ${service.id} already running`); return service;
return service; }
} stopSM(machine);
stopSM(machine); case InterpreterStatus.NotStarted:
case InterpreterStatus.NotStarted: case InterpreterStatus.Stopped:
case InterpreterStatus.Stopped: break;
break; default:
default: console.warn("sm run: unknown status:", service.status, service);
console.warn("sm run: unknown status:", service.status, service); return;
return; break;
break; }
} if (cfg.statemachine.debug || machine.meta?.debug) {
if (cfg.statemachine.debug || machine.meta?.debug) { service.onTransition((state) => {
service.onTransition((state) => { quiet || bot.chat(`sm trans: ${machine.id}, ${state.value}`);
quiet || bot.chat(`sm trans: ${machine.id}, ${state.value}`); quiet || state.meta?.debug && bot.chat(`sm next events: ${machine.id}, ${state.nextEvents}`);
quiet || state.meta?.debug && bot.chat(`sm next events: ${machine.id}, ${state.nextEvents}`); console.log("sm debug: trans", state.value, state);
console.log("sm debug: trans", state.value, state); }).onDone((done) => {
}).onDone((done) => { quiet || bot.chat(`sm done: ${machine.id}, ${done}`);
quiet || bot.chat(`sm done: ${machine.id}, ${done}`); console.log("sm debug: done", done.data, done);
console.log("sm debug: done", done.data, done); });
}); }
} cfg.statemachine.running[machine.id] = service;
cfg.statemachine.running[machine.id] = service; cfg.statemachine.recent = machine;
cfg.statemachine.recent = machine; service.start();
service.start(); // // TODO check if idle state is different (maybe?)
// // 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.value === machine.initialState.value, service.state); console.log("sm run", service.state !== machine.initialState, machine.initialState);
console.log("sm run", service.state !== machine.initialState, machine.initialState); // return machine
// return machine return service;
return service; }
} function stopSM(name = getSM(), quiet = false) {
function stopSM(name = getSM(), quiet = false) { let service = getSM(name, true, quiet);
let service = getSM(name, true, quiet); if (!service)
if (!service) return;
return; const machine = service.machine;
const machine = service.machine; switch (service.status) {
switch (service.status) { case InterpreterStatus.NotStarted:
case InterpreterStatus.NotStarted: case InterpreterStatus.Stopped:
case InterpreterStatus.Stopped: console.log("sm stop status", service.status, service.id, cfg.statemachine.running[service.id]);
console.log("sm stop status", service.status, service.id, cfg.statemachine.running[service.id]); // TODO check if any bugs
// TODO check if any bugs case InterpreterStatus.Running:
case InterpreterStatus.Running: break;
break; default:
default: console.warn("sm stop: unknown status:", service.status);
console.warn("sm stop: unknown status:", service.status); break;
break; }
} service?.stop?.();
service?.stop?.(); cfg.statemachine.running[machine.id] = null;
cfg.statemachine.running[machine.id] = null; delete cfg.statemachine.running[machine.id];
delete cfg.statemachine.running[machine.id]; // return machine
// return machine return service;
return service; }
} function actionSM(action, name = getSM()) {
function actionSM(action, name = getSM()) { if (!action) {
if (!action) { return console.warn("sm action", action);
return console.warn("sm action", action); }
} let service = getSM(name, true, true);
let service = getSM(name, true, true); if (service.status !== InterpreterStatus.Running)
if (service.status !== InterpreterStatus.Running) return;
return; // const machine = service.machine
// const machine = service.machine service.send(action.toLowerCase());
service.send(action.toLowerCase()); }
} function stepSM(command = "", ...message_parts) {
function stepSM(command = "", ...message_parts) { let service = getSM(undefined, true);
let service = getSM(undefined, true); if (!service)
if (!service) return;
return; if (!service.send) {
if (!service.send) { console.warn("sm step: can't send", service.machine);
console.warn("sm step: can't send", service.machine); // TODO start a temporary service to interpret
// TODO start a temporary service to interpret quiet || bot.chat("sm: step doesn't support machines that aren't running yet");
quiet || bot.chat("sm: step doesn't support machines that aren't running yet"); return;
return; }
} if (service?.status !== InterpreterStatus.Running) {
if (service?.status !== InterpreterStatus.Running) { console.warn("sm step: machine not running, attempting start", service);
console.warn("sm step: machine not running, attempting start", service); runSM;
runSM; }
} // const machine = service.machine
// const machine = service.machine switch (command) {
switch (command) { case "edit":
case "edit": // maybe `edit <type>`, like `add`?
// maybe `edit <type>`, like `add`? // where type:
// where type: // context
// context // action
// action // timeout | all timeout
// timeout | all timeout break;
break; case "undo":
case "undo": break;
break; case "del":
case "del": break;
break; case "p":
case "p": case "prev":
case "prev": service?.send("PREV");
service?.send("PREV"); break;
break; case "add":
case "add": // maybe `add <type>`?
// maybe `add <type>`? // where type:
// where type: // context
// context // action
// action // timeout
// timeout case "new":
case "new": break;
break; // case "with":
// case "with": // console.log(this)
// console.log(this) // stepSM(getSM(message_parts[0], true, true), ...message_parts.slice(1))
// stepSM(getSM(message_parts[0], true, true), ...message_parts.slice(1)) // break;
// break; case "help":
case "help": quiet || bot.chat("![sm ]step [ p(rev) | n(ext) ]");
quiet || bot.chat("![sm ]step [ p(rev) | n(ext) ]"); break;
break; case "n":
case "n": case "next":
case "next": default:
default: service?.send("NEXT");
service?.send("NEXT"); quiet || bot.chat("stepped");
quiet || bot.chat("stepped"); break;
break; }
} }
} function tickSM(time = bot.time.timeOfDay, rate = 20) {
function tickSM(time = bot.time.timeOfDay, rate = 20) { if (time % rate !== 0) {
if (time % rate !== 0) { return;
return; }
} console.log("sm tick", rate, time);
console.log("sm tick", rate, time); }
} function debugSM(name = getSM()) {
function debugSM(name = getSM()) { if (!name)
if (!name) return;
return; let service = getSM(name, true);
let service = getSM(name, true); if (!service)
if (!service) return;
return; const machine = service.machine;
const machine = service.machine; machine.meta.debug = !!!machine.meta.debug;
machine.meta.debug = !!!machine.meta.debug; console.info("sm debug", machine.meta, service, machine);
console.info("sm debug", machine.meta, service, machine); cfg.statemachine.quiet || machine.meta.debug && bot.chat("sm debug: " + machine.id);
cfg.statemachine.quiet || machine.meta.debug && bot.chat("sm debug: " + machine.id); }
} function command(message_parts) {
function command(message_parts) { const message_parts2 = message_parts.slice(1);
const message_parts2 = message_parts.slice(1); switch (message_parts[0]) {
switch (message_parts[0]) { case "add":
case "add": command(["new"].concat(message_parts2));
command(["new"].concat(message_parts2)); break;
break; case "finish":
case "finish": case "done":
case "done": case "end":
case "end": command(["save"].concat(message_parts2));
command(["save"].concat(message_parts2)); break;
break; case "do":
case "do": case "load":
case "load": case "start":
case "start": command(["run"].concat(message_parts2));
command(["run"].concat(message_parts2)); break;
break; case "debug":
case "debug": switch (message_parts[1]) {
switch (message_parts[1]) { case "sm":
case "sm": case "global":
case "global": case "meta":
case "meta": cfg.statemachine.debug = !!!cfg.statemachine.debug;
cfg.statemachine.debug = !!!cfg.statemachine.debug; quiet || bot.chat(`sm debug: ${cfg.statemachine.debug}`);
quiet || bot.chat(`sm debug: ${cfg.statemachine.debug}`); break;
break; }
} case "new":
case "new": case "save":
case "save": case "run":
case "run": case "step":
case "step": case "stop":
case "stop": // temp
// temp case "action":
case "action": switch (message_parts2.length) {
switch (message_parts2.length) { case 0:
case 0: console.warn(`sm ${message_parts[0]}: no name, using defaults`);
console.warn(`sm ${message_parts[0]}: no name, using defaults`); case 1:
case 1: // FIXME `this` doesn't work always
// FIXME `this` doesn't work always (this.runSM && this || cfg.plugins.statemachine)[message_parts[0] + "SM"](...message_parts2);
(this.runSM && this || cfg.plugins.statemachine)[message_parts[0] + "SM"](...message_parts2); break;
break; default:
default: if (["action"].includes(message_parts[0])) {
if (["action"].includes(message_parts[0])) { (this.runSM && this || cfg.plugins.statemachine)[message_parts[0] + "SM"](...message_parts2);
(this.runSM && this || cfg.plugins.statemachine)[message_parts[0] + "SM"](...message_parts2); }
} else {
else { console.warn(`sm ${message_parts[0]}: more than 1 arg passed`, message_parts2);
console.warn(`sm ${message_parts[0]}: more than 1 arg passed`, message_parts2); }
} break;
break; }
} break;
break; case "undo":
case "undo": break;
break; case "list":
case "list": case "status":
case "status": // TODO current/recent, updateRate
// TODO current/recent, updateRate const { list, running } = cfg.statemachine;
const { list, running } = cfg.statemachine; console.log("sm list", running, list);
console.log("sm list", running, list); quiet || bot.chat(`${Object.keys(running).length} of ${Object.keys(list).length} active: ${Object.keys(running)}`
quiet || bot.chat(`${Object.keys(running).length} of ${Object.keys(list).length} active: ${Object.keys(running)}` + (message_parts[1] === "all" ? `${Object.keys(list)}` : ''));
+ (message_parts[1] === "all" ? `${Object.keys(list)}` : '')); break;
break; case "quiet":
case "quiet": quiet = cfg.statemachine.quiet = !!!cfg.statemachine.quiet;
quiet = cfg.statemachine.quiet = !!!cfg.statemachine.quiet; quiet || bot.chat(`sm: ${cfg.statemachine.quiet ? "" : "not "}being quiet`);
quiet || bot.chat(`sm: ${cfg.statemachine.quiet ? "" : "not "}being quiet`); break;
break; default:
default: // TODO general helper from declarative commands object
// TODO general helper from declarative commands object quiet || bot.chat(`sm help: !sm [new | step| save | run | list | quiet | debug]`);
quiet || bot.chat(`sm help: !sm [new | step| save | run | list | quiet | debug]`); console.warn("sm unknown command", message_parts);
console.warn("sm unknown command", message_parts); break;
break; }
} return true;
return true; }
} function load(config) {
function load(config) { webserver = cfg.statemachine.webserver = config.statemachine?.webserver || webserver;
webserver = cfg.statemachine.webserver = config.statemachine?.webserver || webserver; config.statemachine = cfg.statemachine || {
config.statemachine = cfg.statemachine || { webserver: null,
webserver: null, // quiet: true,
// quiet: true, quiet: false,
quiet: false, list: {},
list: {}, running: {},
running: {}, draft: null,
draft: null, recent: null,
recent: null, // debug: null,
// debug: null, debug: true,
debug: true, updateRate: updateRate
updateRate: updateRate };
}; cfg = config;
cfg = config; bot = cfg.bot;
bot = cfg.bot; // pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder)
// pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder) // mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
// mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version)) init(undefined, webserver);
init(undefined, webserver); updateRate = cfg.statemachine.updateRate || updateRate;
updateRate = cfg.statemachine.updateRate || updateRate; bot.on('time', tickSM);
bot.on('time', tickSM); // bot.once('time', tickSM, 5)
// bot.once('time', tickSM, 5) console.log("sm load", cfg.statemachine);
console.log("sm load", cfg.statemachine); }
} function unload() {
function unload() { const { list, running } = cfg.statemachine;
const { list, running } = cfg.statemachine; bot.off('time', tickSM);
bot.off('time', tickSM); Object.keys(running).forEach(sm => {
Object.keys(running).forEach(sm => { stopSM(sm);
stopSM(sm); });
}); // delete cfg.statemachine;
// delete cfg.statemachine; cfg.statemachine = null;
cfg.statemachine = null; console.log("sm unload: deleted", cfg.statemachine);
console.log("sm unload: deleted", cfg.statemachine); }
} module.exports = {
module.exports = { load, unload, command, init,
load, unload, command, init, newSM, saveSM, loadSM, runSM, stopSM, actionSM, stepSM, debugSM
newSM, saveSM, loadSM, runSM, stopSM, actionSM, stepSM, debugSM
}; };