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

Compare commits

base: jay:master
Branches Tags
jay:master
jay:cover
jay:nogameplay
..
compare: jay:nogameplay
Branches Tags
jay:master
jay:cover
jay:nogameplay

No commits in common. "master" and "nogameplay" have entirely different histories.
master ... nogameplay

13 changed files with 411 additions and 1482 deletions
Show Stats Expand all files Collapse all files

16
.gitattributes vendored
View File

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

1
.gitignore vendored
View File

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

10
.vscode/settings.json vendored
View File

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

72
lib/index.js
View File

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

285
lib/plugins/command.js
View File

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

30
lib/plugins/eater.js
View File

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

2
lib/plugins/guard.js
View File

@ -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!")
}

342
lib/plugins/informer.js
View File

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

2
lib/plugins/inventory.js
View File

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

344
lib/plugins/mover.js
View File

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

61
lib/plugins/sleeper.js
View File

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

586
lib/plugins/statemachine.js
View File

@ -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);
}
}
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;
// 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 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);
const load = (config) => {
cfg = config
bot = cfg.bot
// cfg.inventory = {
// auto: true,
// quiet: false
// }
// bot.on('chat', inventory)
bot.loadPlugin(pathfinder)
// statemachineInit()
}
return service;
const unload = () => {
// bot.off('chat', inventory)
}
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 }

30
package.json
View File

@ -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/**/*"