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 # production
/build /build
/data
# misc # misc
.DS_Store .DS_Store

10
.vscode/settings.json vendored
View File

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

86
lib/index.js
View File

@ -1,56 +1,50 @@
const env = require("dotenv-packed").parseEnv().parsed const env = require("dotenv-packed").parseEnv().parsed
const fs = require('fs'); const fs = require('fs');
const cfg = { let cfg = {
admin: process.env.MINECRAFT_PLAYER_ADMIN || env.MINECRAFT_PLAYER_ADMIN || console.warn("main: bot admin user not provided"), admin: "Applezaus",
mods: process.env.MINECRAFT_PLAYER_MODS || env.MINECRAFT_PLAYER_MODS || [], // json array, mods: ["Applezaus", "tanner6", "Angram42", "[WEB] Angram42", "[WEB] Applezaus"],
stateMachines: {} stateMachines: {}
} }
const mineflayer = require("mineflayer"); const mineflayer = require("mineflayer");
// const { createGetAccessor } = require('typescript'); // 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 ?
host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost', // Change this to the ip you want. mineflayer.createBot({
port: parseInt(process.argv[3]) || process.env.MINECRAFT_PORT || env.MINECRAFT_PORT // || 58471, 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,
: })
{ :
host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost', // Change this to the ip you want. mineflayer.createBot({
username: process.argv[3] || process.env.MINECRAFT_USER || env.MINECRAFT_USER, host: process.argv[2] || process.env.MINECRAFT_HOST || env.MINECRAFT_HOST || 'localhost', // Change this to the ip you want.
password: process.argv[4] || process.env.MINECRAFT_PASS || env.MINECRAFT_PASS, username: process.argv[3] || process.env.MINECRAFT_USER || env.MINECRAFT_USER,
// port: process.argv[5] || process.env.MINECRAFT_PORT || 58471, 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 = {} let plugins = {}
function loadplugin(pluginname, pluginpath = './plugins/' + pluginname) { function loadplugin(pluginname, pluginpath) {
try { try {
plugins[pluginname] = require(pluginpath) plugins[pluginname] = require(pluginpath)
plugins[pluginname].load(cfg) plugins[pluginname].load(cfg)
} catch (error) { } catch (error) {
if (error.code == 'MODULE_NOT_FOUND') { if (error.code == 'MODULE_NOT_FOUND') {
console.warn('plugin not used:', pluginpath) console.warn('plugin not used:', pluginpath)
} else if (plugins[pluginname] && !plugins[pluginname].load) {
unloadplugin(pluginname, pluginpath)
} else { } else {
console.error(error) console.error(error)
} }
} }
} }
function unloadplugin(pluginname, pluginpath = './plugins/' + pluginname) { function unloadplugin(pluginname, pluginpath) {
pluginpath = pluginpath ? pluginpath : './plugins/' + pluginname
const plugin = require.resolve(pluginpath) const plugin = require.resolve(pluginpath)
try { try {
if (plugin && require.cache[plugin]) { if (plugin && require.cache[plugin]) {
// `unload()` isn't exported sometimes, require.cache[plugin].exports.unload()
// when plugin isn't properly loaded
require.cache[plugin].exports?.unload?.()
delete plugins[pluginname] delete plugins[pluginname]
delete require.cache[plugin] 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 } if (!/\.js$/.test(filename)) { return }
filename = filename.replace("\\", "/") // windows
if (!cfg.fsTimeout) { if (!cfg.fsTimeout) {
console.info(event, filename) console.info(event, filename)
const fullpluginpath = pluginpath + filename pluginpath = (pluginpath ? pluginpath : './plugins/') + filename
const pluginname = (filename.split(".js")[0]).replace(/\/.+/, "")
pluginpath = pluginpath + pluginname
const hassubplugin = fullpluginpath.replace(/\.js$/, "") !== pluginpath
const check = Object.keys(cfg.plugins) const check = Object.keys(cfg.plugins)
console.info(`reload file: ./lib/${fullpluginpath}`) console.info(`reload file:`, pluginpath)
const plugin = require.resolve(fullpluginpath) const plugin = require.resolve(pluginpath)
if (plugin && require.cache[plugin]) { if (plugin && require.cache[plugin]) {
// console.debug(Object.keys(cfg.plugins)) // 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") 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 (Object.keys(cfg.plugins).length != check.length) {
// If left < right : // If left < right :
// - new plugin that's not registered in cfg.plugins, so added // - 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) // console.log('file.js %s event', event)
} }
fs.watch('./lib/plugins', { recursive: true }, reloadplugin) fs.watch('./lib/plugins', reloadplugin)
cfg.bot = bot cfg.bot = bot
// TODO better name, or switch to array cfg.botAddress = new RegExp(`^${bot.username} (!.+)`)
cfg.botAddressPrefix = '!'
cfg.quiet = true cfg.quiet = true
@ -107,23 +92,18 @@ cfg.quiet = true
bot.once("spawn", () => { bot.once("spawn", () => {
plugins = { plugins = {
command: require('./plugins/command'), command: require('./plugins/command'),
informer: require('./plugins/informer'),
inventory: require('./plugins/inventory'),
finder: require('./plugins/finder'),
mover: require('./plugins/mover'),
sleeper: require('./plugins/sleeper'), sleeper: require('./plugins/sleeper'),
eater: require('./plugins/eater'),
armor: require('./plugins/armor'), armor: require('./plugins/armor'),
mover: require('./plugins/mover'),
guard: require('./plugins/guard'), guard: require('./plugins/guard'),
inventory: require('./plugins/inventory'),
eater: require('./plugins/eater'),
finder: require('./plugins/finder'),
// miner: require('./plugins/miner.js'), // miner: require('./plugins/miner.js'),
statemachine: require('./plugins/statemachine'), // statemachine: require('./plugins/statemachine'),
} }
cfg.plugins = plugins 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)) { for (const plugin of Object.values(plugins)) {
try { try {

301
lib/plugins/command.js
View File

@ -1,5 +1,5 @@
const v = require('vec3') const v = require('vec3')
let mcData let mcData = require('minecraft-data')
let cfg = {} let cfg = {}
let bot = {} let bot = {}
@ -27,13 +27,14 @@ function checkItemExists(name) {
} }
const events = { const events = {
whisper: function command_whisper(username, _botusername, message, ...history) { whisper: function command_whisper(username, message) {
if ([bot.username, "me"].includes(username)) return // whisper back from server (afk msges, etc) 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) {
console.info("whispered command", _botusername, message)
message = message.replace("\\", "@") message = message.replace("\\", "@")
if (message.startsWith(cfg.botAddressPrefix)) { console.info("whispered command", message)
if (/^!/.test(message)) {
command(username, message) command(username, message)
} else { } else {
bot.chat(message) bot.chat(message)
@ -41,53 +42,16 @@ const events = {
} }
} else { } else {
bot.whisper(cfg.admin, `gossip ${username}: ${message}`) bot.whisper(cfg.admin, `gossip ${username}: ${message}`)
console.info(username, "whispered", _botusername, message) console.info(username, "whispered", message)
} }
} }
, chat: command , chat: command
, kicked: function rejoin(reason, loggedIn) { , kicked: (reason, loggedIn) => console.warn(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))
} }
const events_registered = [] const events_registered = []
function command(username, message) { function command(username, message) {
// TODO better name, maybe an array?
cfg.botAddressPrefix = cfg.botAddressPrefix || "!"
function fuzzyRespond(responses, probability = 1, timeout = 1) { function fuzzyRespond(responses, probability = 1, timeout = 1) {
if (Math.random() < probability) { if (Math.random() < probability) {
const response = responses[Math.floor(Math.random() * responses.length)] 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 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)) { if (message.startsWith("!") || cfg.botAddress.test(message)) {
message = cfg.botAddressRegex.test(message) ? cfg.botAddressRegex.exec(message)[1] : message message = cfg.botAddress.test(message) ? cfg.botAddress.exec(message)[1] : message
console.log(message)
// remove `!`
message = message.startsWith(cfg.botAddressPrefix) ? message.slice(cfg.botAddressPrefix.length) : message
console.log(message)
message = message.slice(1) // remove `!`
// TODO command dispatchEvent, for aliases // TODO command dispatchEvent, for aliases
function subcommand(message) { function subcommand(message) {
const message_parts = message.split(/\s+/) const message_parts = message.split(/\s+/)
@ -220,44 +183,104 @@ function command(username, message) {
break; break;
case "follow": case "follow":
switch (message_parts.length) { subcommand("go follow me")
case 1:
subcommand("go follow me")
break;
default:
subcommand("go " + message)
break;
}
break; break;
case "come": case "come":
switch (message_parts[1]) { subcommand("go follow once")
case "close":
case "closer":
subcommand("go follow close")
break
case "up":
case "down":
cfg.plugins.mover.moveY(player.position)
break
default:
subcommand("go follow once")
}
break; break;
case "ride":
case "mount":
cfg.plugins.mover.command(message_parts)
break
case "unride":
case "getoff":
case "unmount":
case "dismount":
bot.dismount()
bot.vehicle = void 0
break
case "move": case "move":
case "go": case "go":
cfg.plugins.mover.command(message_parts.slice(1), player) // 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:
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;
}
break
case 2:
todo()
// bot.lookAt({}) goalxz?
break
case 3:
//TODO more checks
cfg.plugins.mover.moveNear(message_parts2)
break
default:
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;
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 2:
// bot.lookAt({}) goalxz?
// break
// case 3:
//TODO more checks
// cfg.plugins.mover.moveNear(message_parts2)
// break
default:
todo()
break
}
break
case "stop":
cfg.plugins.mover.stop()
break
default:
return todo()
break;
}
break; break;
case "attack": case "attack":
@ -308,8 +331,6 @@ function command(username, message) {
break; break;
} }
break break
// TODO move look (and maybe find) to informer plugin?
case "look":
case "lookat": case "lookat":
// const coords = v(message_parts.splice(1)) // const coords = v(message_parts.splice(1))
switch (message_parts.length) { switch (message_parts.length) {
@ -320,7 +341,7 @@ function command(username, message) {
switch (message_parts[1]) { switch (message_parts[1]) {
case "me": case "me":
if (player) { if (player) {
bot.lookAt(player.position.offset(0, 1, 0)) bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position))
} else { } else {
cfg.quiet || bot.chat("can't see you") cfg.quiet || bot.chat("can't see you")
} }
@ -328,16 +349,17 @@ function command(username, message) {
case "this": case "this":
// TODO lookat the block the user is looking at // TODO lookat the block the user is looking at
// Currently looks player position
if (player) { if (player) {
bot.lookAt(player.position) bot.lookAt((new v.Vec3(0, 1, 0)).add(player.position))
todo()
} else { } else {
cfg.quiet || bot.chat("can't see you") cfg.quiet || bot.chat("can't see you")
} }
break;
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(aPlayer.position.offset(0, 1, 0)) if (aPlayer) bot.lookAt((new v.Vec3(0, 1, 0)).add(aPlayer.position))
break; break;
} }
break break
@ -353,8 +375,17 @@ function command(username, message) {
break break
} }
break break
case "info": case "ride":
cfg.plugins.informer.command(message_parts.splice(1), player) case "mount":
bot.mount(bot.nearestEntity())
break
case "getoff":
case "unmount":
case "dismount":
bot.dismount()
break
case "go":
bot.moveVehicle(0, 10)
break break
// case "use": // case "use":
// bot.useOn(bot.nearestEntity()) // bot.useOn(bot.nearestEntity())
@ -385,62 +416,29 @@ function command(username, message) {
// case "take": // case "take":
// // TODO take only what's requested, then throw all the rest // // TODO take only what's requested, then throw all the rest
// // TODO take all // // TODO take all
// case "toss":
// TODO move subcommands to cfg.plugins.inventory.itemByName // case "drop":
case "toss": // if (!message_parts[1]) { return false } // FIXME, works but ugly
case "drop": // if (!checkItemExists(message_parts[1])) { return false }
if (!message_parts[1]) { return false } // FIXME, works but ugly // switch (message_parts.length) {
if (!mcData.findItemOrBlockByName(message_parts[1])) { // case 2:
console.log("doesn't exist:", message_parts[1]) // bot.toss(mcData.blocksByName[message_parts[1]].id)
cfg.quiet || bot.chat(`item doesn't exist: ${message_parts[1]}`) // break
return false // case 3:
} // bot.tossStack(
const item = cfg.plugins.inventory.itemByName(message_parts[1]) // mcData.itemsByName[message_parts[1]].id,
if (!item) { // (err) => {
console.log("don't have:", message_parts[1]) // if (err) {
cfg.quiet || bot.chat(`don't have item: ${message_parts[1]}`) // console.log(err)
return false // bot.chat(err)
} // }
switch (message_parts.length) { // }
case 2: // )
bot.tossStack( // break
item, // default:
(err) => { // break
if (err) { // }
console.error(err) // break;
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 "location": case "location":
// TODO put in /lib/location // TODO put in /lib/location
switch (message_parts[1]) { switch (message_parts[1]) {
@ -498,7 +496,7 @@ function command(username, message) {
case "howdy": case "howdy":
case "heyo": case "heyo":
case "yo": 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 // TODO sneak
// function swingArm() { // function swingArm() {
@ -539,14 +537,13 @@ const load = (config) => {
cfg = config cfg = config
bot = cfg.bot 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)) { for (const [key, fn] of Object.entries(events)) {
events_registered.push( events_registered.push(
bot.on(key, fn) bot.on(key, fn)
) )
} }
mcData = require('minecraft-data')(bot.version)
// bot._client.on("chat", _clientSystemMessage)
} }
const unload = () => { const unload = () => {
@ -556,8 +553,6 @@ const unload = () => {
events_registered.shift() events_registered.shift()
} }
console.log("events_registered:", bot._eventsCount) console.log("events_registered:", bot._eventsCount)
// bot._client.off("chat", _clientSystemMessage)
} }
module.exports = { load, unload, events_registered, command } module.exports = { load, unload, events_registered, command }

32
lib/plugins/eater.js
View File

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

2
lib/plugins/guard.js
View File

@ -71,7 +71,9 @@ 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!")
} }

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) bot.off('chat', inventory)
} }
module.exports = { load, unload, equipItem, craftItem, itemByName } module.exports = { load, unload, equipItem, craftItem }

352
lib/plugins/mover.js
View File

@ -1,355 +1,71 @@
// import { EntityFilters } from "mineflayer-statemachine"
// import v from "vec3"
// import { Movements } from "mineflayer-pathfinder"
// const mineflayer = require('mineflayer')
const { Movements } = require('mineflayer-pathfinder') const { Movements } = require('mineflayer-pathfinder')
// const { GoalBLah } = require('mineflayer-pathfinder').goals
const v = require('vec3') const v = require('vec3')
let cfg = {} let cfg = {}
let bot = {} let bot = {}
// let moving // let moving
let pathfinder let pathfinder
let mcData
let movements = [] let movements = []
function initMoves(bot = bot, mcData = bot.mcData) { function initMoves(bot = bot, mcData = require('minecraft-data')(bot.version)) {
if (movements.length > 0) { let defaultMove = new Movements(bot, mcData)
bot.pathfinder.setMovements(movements.defaultMove) defaultMove.canDig = false
return console.warn("go init: movements already initialized!", movements) defaultMove.scafoldingBlocks.push(mcData.blocksByName.slime_block.id)
} // defaultMove.blocksCantBreak.add(mcData.blocksByName.glass.id)
const normalMove = new Movements(bot, mcData) // defaultMove.blocksToAvoid.add(mcData.blocksByName.magma.id)
normalMove.canDig = false movements.defaultMove = defaultMove
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]
const aggresiveMove = new Movements(bot, mcData) bot.pathfinder.setMovements(defaultMove)
//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)
} }
function moveNear(pos, distance = 3) { function moveNear(pos, distance = 3) {
const { GoalNear } = require('mineflayer-pathfinder').goals const { GoalNear } = require('mineflayer-pathfinder').goals
cfg.quiet || bot.chat(`moving to ${pos}`)
pos = v(pos) pos = v(pos)
cfg.quiet || bot.chat(`moving to ${pos.floored()}`)
bot.pathfinder.setMovements(movements.defaultMove) bot.pathfinder.setMovements(movements.defaultMove)
bot.pathfinder.setGoal(new GoalNear(pos.x, pos.y, pos.z, distance)) bot.pathfinder.setGoal(new GoalNear(pos.x, pos.y, pos.z, distance))
} }
function moveXZ(pos) { function follow(entity, dynamic = true) {
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) {
console.assert(entity) console.assert(entity)
const { GoalFollow } = require('mineflayer-pathfinder').goals const { GoalFollow } = require('mineflayer-pathfinder').goals
// console.log(entity)
cfg.quiet || bot.chat(
`following ${entity.type cfg.quiet && console.log(entity)
}: ${entity.username || entity.displayName || bot.chat(
}${dynamic ? "" : " once"}` `following ${entity.type
) }: ${entity.username || entity.displayName
}${dynamic ? "" : " once"}`
)
entity = entity.entity ? entity.entity : entity entity = entity.entity ? entity.entity : entity
// console.log(entity) // console.log(entity)
bot.pathfinder.setMovements(movements.defaultMove) bot.pathfinder.setMovements(movements.defaultMove)
bot.pathfinder.setGoal(new GoalFollow(entity, distance), dynamic) bot.pathfinder.setGoal(new GoalFollow(entity, 3), 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))
}
} }
function hit(blockOrEntity) { function hit(blockOrEntity) {
bot.chat(`hitting ${entity.name || entity.type}`) 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() { function stop() {
bot.pathfinder.setGoal(null) bot.pathfinder.setGoal(null)
bot.stopDigging() 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) => { const load = (config) => {
cfg = config cfg = config
bot = cfg.bot bot = cfg.bot
@ -361,23 +77,19 @@ const load = (config) => {
movements: [] movements: []
} }
mcData = bot.mcData || (bot.mcData = require('minecraft-data')(bot.version))
pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder) pathfinder = bot.pathfinder || bot.loadPlugin(require('mineflayer-pathfinder').pathfinder)
// initMoves(bot, mcData) // initMoves(bot, mcData)
setTimeout(initMoves, 500, bot, mcData) setTimeout(initMoves, 500, bot)
bot.on('goal_reached', goalReached)
// bot.loadPlugin(pathfinder)
// bot.on('time', hello)
} }
const unload = () => { const unload = () => {
stop() // TODO stop pathfinding maybe?
bot.off('goal_reached', goalReached)
} }
module.exports = { module.exports = { load, unload, stop, initMoves, moveNear, follow }
load, unload, command,
stop, initMoves,
moveNear, moveXZ, moveY, follow,
ride
}

73
lib/plugins/sleeper.js
View File

@ -7,78 +7,49 @@ let bot = {}
let inv let inv
// cfg.autosleep = false // 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){ if(bot.game.dimension !== "minecraft:overworld" || cfg.sleep.force){
!quiet && bot.chat("can't sleep, not in overworld now") !quiet && bot.chat("can't sleep, not in overworld now")
return return
} }
if (bot.isSleeping && !cfg.sleep.force) {
!quiet && bot.chat("already in bed!")
return
}
let bed = bot.findBlock({ let bed = bot.findBlock({
matching: block => bot.isABed(block) matching: block => bot.isABed(block)
}) })
let bed_occupied = bed && bot.parseBedMetadata(bed).occupied let bedstatus = bed && bot.parseBedMetadata(bed).occupied ? "n unoccupied" : ""
if (bed && bed_occupied) { if(bed && bedstatus == "n unoccupied"){
bot.lookAt(bed.position) bot.lookAt(bed.position)
bed = bot.findBlock({ bed = bot.findBlock({
matching: block => bot.isABed(block) && !bot.parseBedMetadata(block).occupied matching: block => bot.isABed(block) && !bot.parseBedMetadata(block).occupied
}) || bed }) || 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.lookAt(bed.position)
bot.waitForChunksToLoad(() => { bot.waitForChunksToLoad(() => {
cfg.plugins.mover && cfg.plugins.mover.moveNear(bed.position, 2) cfg.plugins.moveNear(bed.position)
bot.once('goal_reached', (goal) => { bot.sleep(bed, (err) => {
console.info(goal) if (err) {
try { !quiet && bot.chat(`can't sleep: ${err.message}`)
bot.sleep(bed, (err) => { } else {
if (err) { !quiet && bot.chat("zzz")
!quiet && bot.chat(`can't sleep: ${err.message}`) console.log("sleeping? ", bot.isSleeping)
} else { // hack until this is fixed
!quiet && bot.chat("zzz") // bot.isSleeping = bot.isSleeping ? bot.isSleeping : true
// apparently, `bot.isSleeping = true` takes a while bot.isSleeping = true
// maybe it's async
console.log("sleeping? ", bot.isSleeping)
}
})
} catch (error) {
console.error(error)
} }
}) })
}) })
} else if (bed = bot.inventory.items().filter(bot.isABed)[0]) { } else if (inv && inv.equipItem("red_bed", "hand", true)) {
const v = require('vec3') // doesn't work fortunately
bot.equip(bed, "hand", (err) => { if (err) console.error(err) }) // FIXME: DONT IMPLEMENT until it is detected as NOT NETHER
bot.waitForChunksToLoad(() => { // bot.placeBlock()
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 { } else {
// TODO: use mover // TODO: use mover
// bot.gameplay.solveFor( // bot.gameplay.solveFor(
// new ObtainItem("bed"), (err) => { // new ObtainItem("bed"), (err) => {
// if (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) { if (!bot.time.isDay && !cfg.sleep.timeoutFn && cfg.sleep.auto && !bot.isSleeping) {
sleep() sleep()
cfg.sleep.timeoutFn = setTimeout(() => { cfg.sleep.timeoutFn = null }, cfg.sleep.timeout) 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)
} }
} }

588
lib/plugins/statemachine.js
View File

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

30
package.json
View File

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