mineflayer 3.14.1 → 3.18.0

package/examples/anvil.js

@@ -63,24 +63,22 @@ bot.on('chat', async (username, message) => {
   }
 })
 
-function tossItem (name, amount) {
+async function tossItem (name, amount) {
   amount = parseInt(amount, 10)
   const item = itemByName(name)
   if (!item) {
     bot.chat(`I have no ${name}`)
-  } else if (amount) {
-    bot.toss(item.type, null, amount, checkIfTossed)
   } else {
-    bot.tossStack(item, checkIfTossed)
-  }
-
-  function checkIfTossed (err) {
-    if (err) {
+    try {
+      if (amount) {
+        await bot.toss(item.type, null, amount)
+        bot.chat(`tossed ${amount} x ${name}`)
+      } else {
+        await bot.tossStack(item)
+        bot.chat(`tossed ${name}`)
+      }
+    } catch (err) {
       bot.chat(`unable to toss: ${err.message}`)
-    } else if (amount) {
-      bot.chat(`tossed ${amount} x ${name}`)
-    } else {
-      bot.chat(`tossed ${name}`)
     }
   }
 }

package/examples/chest.js

@@ -220,38 +220,36 @@ async function watchFurnace () {
       bot.removeListener('chat', onChat)
     }
 
-    function putInFurnace (where, name, amount) {
+    async function putInFurnace (where, name, amount) {
       const item = itemByName(furnace.items(), name)
       if (item) {
         const fn = {
           input: furnace.putInput,
           fuel: furnace.putFuel
         }[where]
-        fn.call(furnace, item.type, null, amount, (err) => {
-          if (err) {
-            bot.chat(`unable to put ${amount} ${item.name}`)
-          } else {
-            bot.chat(`put ${amount} ${item.name}`)
-          }
-        })
+        try {
+          await fn.call(furnace, item.type, null, amount)
+          bot.chat(`put ${amount} ${item.name}`)
+        } catch (err) {
+          bot.chat(`unable to put ${amount} ${item.name}`)
+        }
       } else {
         bot.chat(`unknown item ${name}`)
       }
     }
 
-    function takeFromFurnace (what) {
+    async function takeFromFurnace (what) {
       const fn = {
         input: furnace.takeInput,
         fuel: furnace.takeFuel,
         output: furnace.takeOutput
       }[what]
-      fn.call(furnace, (err, item) => {
-        if (err) {
-          bot.chat(`unable to take ${item.name}`)
-        } else {
-          bot.chat(`took ${item.name}`)
-        }
-      })
+      try {
+        const item = await fn.call(furnace)
+        bot.chat(`took ${item.name}`)
+      } catch (err) {
+        bot.chat('unable to take')
+      }
     }
   }
 }

package/examples/digger.js

@@ -56,7 +56,7 @@ function sayItems (items = bot.inventory.items()) {
   }
 }
 
-function dig () {
+async function dig () {
   let target
   if (bot.targetDigBlock) {
     bot.chat(`already digging ${bot.targetDigBlock.name}`)
@@ -64,19 +64,16 @@ function dig () {
     target = bot.blockAt(bot.entity.position.offset(0, -1, 0))
     if (target && bot.canDigBlock(target)) {
       bot.chat(`starting to dig ${target.name}`)
-      bot.dig(target, onDiggingCompleted)
+      try {
+        await bot.dig(target)
+        bot.chat(`finished digging ${target.name}`)
+      } catch (err) {
+        console.log(err.stack)
+      }
     } else {
       bot.chat('cannot dig')
     }
   }
-
-  function onDiggingCompleted (err) {
-    if (err) {
-      console.log(err.stack)
-      return
-    }
-    bot.chat(`finished digging ${target.name}`)
-  }
 }
 
 function build () {
@@ -87,28 +84,26 @@ function build () {
 
   let tryCount = 0
 
-  function placeIfHighEnough () {
+  async function placeIfHighEnough () {
     if (bot.entity.position.y > jumpY) {
-      bot.placeBlock(referenceBlock, vec3(0, 1, 0), (err) => {
-        if (err) {
-          tryCount++
-          if (tryCount > 10) {
-            bot.chat(err.message)
-            bot.setControlState('jump', false)
-            bot.removeListener('move', placeIfHighEnough)
-            return
-          }
-          return
-        }
+      try {
+        await bot.placeBlock(referenceBlock, vec3(0, 1, 0))
         bot.setControlState('jump', false)
         bot.removeListener('move', placeIfHighEnough)
         bot.chat('Placing a block was successful')
-      })
+      } catch (err) {
+        tryCount++
+        if (tryCount > 10) {
+          bot.chat(err.message)
+          bot.setControlState('jump', false)
+          bot.removeListener('move', placeIfHighEnough)
+        }
+      }
     }
   }
 }
 
-function equipDirt () {
+async function equipDirt () {
   const mcData = require('minecraft-data')(bot.version)
   let itemsByName
   if (bot.supportFeature('itemsAreNotBlocks')) {
@@ -116,13 +111,12 @@ function equipDirt () {
   } else if (bot.supportFeature('itemsAreAlsoBlocks')) {
     itemsByName = 'blocksByName'
   }
-  bot.equip(mcData[itemsByName].dirt.id, 'hand', (err) => {
-    if (err) {
-      bot.chat(`unable to equip dirt: ${err.message}`)
-    } else {
-      bot.chat('equipped dirt')
-    }
-  })
+  try {
+    await bot.equip(mcData[itemsByName].dirt.id, 'hand')
+    bot.chat('equipped dirt')
+  } catch (err) {
+    bot.chat(`unable to equip dirt: ${err.message}`)
+  }
 }
 
 function itemToString (item) {

package/examples/inventory.js

@@ -77,24 +77,22 @@ function sayItems (items = null) {
   }
 }
 
-function tossItem (name, amount) {
+async function tossItem (name, amount) {
   amount = parseInt(amount, 10)
   const item = itemByName(name)
   if (!item) {
     bot.chat(`I have no ${name}`)
-  } else if (amount) {
-    bot.toss(item.type, null, amount, checkIfTossed)
   } else {
-    bot.tossStack(item, checkIfTossed)
-  }
-
-  function checkIfTossed (err) {
-    if (err) {
+    try {
+      if (amount) {
+        await bot.toss(item.type, null, amount)
+        bot.chat(`tossed ${amount} x ${name}`)
+      } else {
+        await bot.tossStack(item)
+        bot.chat(`tossed ${name}`)
+      }
+    } catch (err) {
       bot.chat(`unable to toss: ${err.message}`)
-    } else if (amount) {
-      bot.chat(`tossed ${amount} x ${name}`)
-    } else {
-      bot.chat(`tossed ${name}`)
     }
   }
 }

package/index.d.ts

@@ -189,6 +189,7 @@ export interface Bot extends TypedEmitter<BotEvents> {
   heldItem: Item | null
   currentWindow: Window | null
   simpleClick: simpleClick
+  tablist: Tablist
 
   connect: (options: BotOptions) => void
 
@@ -228,7 +229,6 @@ export interface Bot extends TypedEmitter<BotEvents> {
 
   tabComplete: (
     str: string,
-    cb: (matches: string[]) => void,
     assumeCommand?: boolean,
     sendBlockInSight?: boolean
   ) => Promise<string[]>
@@ -247,11 +247,11 @@ export interface Bot extends TypedEmitter<BotEvents> {
 
   hasPlugin: (plugin: Plugin) => boolean
 
-  sleep: (bedBlock: Block, cb?: (err?: Error) => void) => Promise<void>
+  sleep: (bedBlock: Block) => Promise<void>
 
   isABed: (bedBlock: Block) => void
 
-  wake: (cb?: (err?: Error) => void) => Promise<void>
+  wake: () => Promise<void>
 
   setControlState: (control: ControlState, state: boolean) => void
 
@@ -261,38 +261,34 @@ export interface Bot extends TypedEmitter<BotEvents> {
 
   getExplosionDamages: (targetEntity: Entity, position: Vec3, radius: number, rawDamages?: boolean) => number | null
 
-  lookAt: (point: Vec3, force?: boolean, callback?: () => void) => Promise<void>
+  lookAt: (point: Vec3, force?: boolean) => Promise<void>
 
   look: (
     yaw: number,
     pitch: number,
-    force?: boolean,
-    callback?: () => void
+    force?: boolean
   ) => Promise<void>
 
   updateSign: (block: Block, text: string) => void
 
   equip: (
     item: Item | number,
-    destination: EquipmentDestination | null,
-    callback?: (error?: Error) => void
+    destination: EquipmentDestination | null
   ) => Promise<void>
 
   unequip: (
-    destination: EquipmentDestination | null,
-    callback?: () => void
+    destination: EquipmentDestination | null
   ) => Promise<void>
 
-  tossStack: (item: Item, callback?: (error?: Error) => void) => Promise<void>
+  tossStack: (item: Item) => Promise<void>
 
   toss: (
     itemType: number,
     metadata: number | null,
-    count: number | null,
-    callback?: (err?: Error) => void
+    count: number | null
   ) => Promise<void>
 
-  dig: ((block: Block, forceLook?: boolean | 'ignore', callback?: (err?: Error) => void) => Promise<void>) & ((block: Block, forceLook: boolean | 'ignore', digFace: 'auto' | Vec3 | 'raycast', callback?: (err?: Error) => void) => Promise<void>)
+  dig: ((block: Block, forceLook?: boolean | 'ignore') => Promise<void>) & ((block: Block, forceLook: boolean | 'ignore', digFace: 'auto' | Vec3 | 'raycast') => Promise<void>)
 
   stopDigging: () => void
 
@@ -302,15 +298,15 @@ export interface Bot extends TypedEmitter<BotEvents> {
 
   placeEntity: (referenceBlock: Block, faceVector: Vec3) => Promise<Entity>
 
-  activateBlock: (block: Block, callback?: (err?: Error) => void) => Promise<void>
+  activateBlock: (block: Block) => Promise<void>
 
-  activateEntity: (block: Entity, callback?: (err?: Error) => void) => Promise<void>
+  activateEntity: (block: Entity) => Promise<void>
 
-  activateEntityAt: (block: Entity, position: Vec3, callback?: (err?: Error) => void) => Promise<void>
+  activateEntityAt: (block: Entity, position: Vec3) => Promise<void>
 
-  consume: (callback?: (err?: Error) => void) => Promise<void>
+  consume: () => Promise<void>
 
-  fish: (callback?: (err?: Error) => void) => Promise<void>
+  fish: () => Promise<void>
 
   activateItem: (offhand?: boolean) => void
 
@@ -333,14 +329,12 @@ export interface Bot extends TypedEmitter<BotEvents> {
   craft: (
     recipe: Recipe,
     count: number | null,
-    craftingTable: Block,
-    callback?: () => void
+    craftingTable: Block
   ) => Promise<void>
 
   writeBook: (
     slot: number,
-    pages: string[],
-    callback?: (err?: Error) => void
+    pages: string[]
   ) => Promise<void>
 
   openContainer: (chest: Block | Entity) => Promise<Chest | Furnace | Dispenser>
@@ -362,8 +356,7 @@ export interface Bot extends TypedEmitter<BotEvents> {
   trade: (
     villagerInstance: Villager,
     tradeIndex: string | number,
-    times?: number,
-    cb?: (err?: Error) => void
+    times?: number
   ) => Promise<void>
 
   setCommandBlock: (pos: Vec3, command: string, trackOutput: boolean) => void
@@ -371,23 +364,21 @@ export interface Bot extends TypedEmitter<BotEvents> {
   clickWindow: (
     slot: number,
     mouseButton: number,
-    mode: number,
-    cb?: (err?: Error) => void
+    mode: number
   ) => Promise<void>
 
   putSelectedItemRange: (
     start: number,
     end: number,
     window: Window,
-    slot: any,
-    cb?: (err?: Error) => void
+    slot: any
   ) => Promise<void>
 
-  putAway: (slot: number, cb?: (err?: Error) => void) => Promise<void>
+  putAway: (slot: number) => Promise<void>
 
   closeWindow: (window: Window) => void
 
-  transfer: (options: TransferOptions, cb?: (err?: Error) => void) => Promise<void>
+  transfer: (options: TransferOptions) => Promise<void>
 
   openBlock: (block: Block, Class: new () => EventEmitter) => Promise<void>
 
@@ -395,15 +386,14 @@ export interface Bot extends TypedEmitter<BotEvents> {
 
   moveSlotItem: (
     sourceSlot: number,
-    destSlot: number,
-    cb?: (err?: Error) => void
+    destSlot: number
   ) => Promise<void>
 
   updateHeldItem: () => void
 
   getEquipmentDestSlot: (destination: string) => number
 
-  waitForChunksToLoad: (cb?: (err?: Error) => void) => Promise<void>
+  waitForChunksToLoad: () => Promise<void>
 
   nearestEntity: (filter?: (entity: Entity) => boolean) => Entity | null
 
@@ -427,6 +417,11 @@ export interface simpleClick {
   rightMouse: (slot: number) => Promise<void>
 }
 
+export interface Tablist {
+  header: ChatMessage
+  footer: ChatMessage
+}
+
 export interface chatPatternOptions {
   repeat: boolean
   parse: boolean
@@ -573,11 +568,10 @@ export interface TransferOptions {
 export interface creativeMethods {
   setInventorySlot: (
     slot: number,
-    item: Item | null,
-    callback?: (error?: Error) => void
+    item: Item | null
   ) => Promise<void>
 
-  flyTo: (destination: Vec3, cb?: () => void) => Promise<void>
+  flyTo: (destination: Vec3) => Promise<void>
 
   startFlying: () => void
 
@@ -628,15 +622,13 @@ export class Chest extends (EventEmitter as new () => TypedEmitter<StorageEvents
   deposit (
     itemType: number,
     metadata: number | null,
-    count: number | null,
-    cb?: (err?: Error) => void
+    count: number | null
   ): Promise<void>;
 
   withdraw (
     itemType: number,
     metadata: number | null,
-    count: number | null,
-    cb?: (err?: Error) => void
+    count: number | null
   ): Promise<void>;
 
   count (itemType: number, metadata: number | null): number;
@@ -652,24 +644,22 @@ export class Furnace extends (EventEmitter as new () => TypedEmitter<FurnaceEven
 
   close (): void;
 
-  takeInput (cb: (err: Error | null, item: Item) => void): Promise<Item>;
+  takeInput (): Promise<Item>;
 
-  takeFuel (cb: (err: Error | null, item: Item) => void): Promise<Item>;
+  takeFuel (): Promise<Item>;
 
-  takeOutput (cb: (err: Error | null, item: Item) => void): Promise<Item>;
+  takeOutput (): Promise<Item>;
 
   putInput (
     itemType: number,
     metadata: number | null,
-    count: number,
-    cb?: (err?: Error) => void
+    count: number
   ): Promise<void>;
 
   putFuel (
     itemType: number,
     metadata: number | null,
-    count: number,
-    cb?: (err?: Error) => void
+    count: number
   ): Promise<void>;
 
   inputItem (): Item;
@@ -687,15 +677,13 @@ export class Dispenser extends (EventEmitter as new () => TypedEmitter<StorageEv
   deposit (
     itemType: number,
     metadata: number | null,
-    count: number | null,
-    cb?: (err?: Error) => void
+    count: number | null
   ): Promise<void>;
 
   withdraw (
     itemType: number,
     metadata: number | null,
-    count: number | null,
-    cb?: (err?: Error) => void
+    count: number | null
   ): Promise<void>;
 
   count (itemType: number, metadata: number | null): number;
@@ -713,15 +701,14 @@ export class EnchantmentTable extends (EventEmitter as new () => TypedEmitter<Co
   targetItem (): Item;
 
   enchant (
-    choice: string | number,
-    cb?: (err: Error | null, item: Item) => void
+    choice: string | number
   ): Promise<Item>;
 
-  takeTargetItem (cb?: (err: Error | null, item: Item) => void): Promise<Item>;
+  takeTargetItem (): Promise<Item>;
 
-  putTargetItem (item: Item, cb?: (err: Error | null) => void): Promise<Item>;
+  putTargetItem (item: Item): Promise<Item>;
 
-  putLapis (item: Item, cb?: (err: Error | null) => void): Promise<Item>;
+  putLapis (item: Item): Promise<Item>;
 }
 
 export class Anvil {
@@ -742,13 +729,18 @@ export class Villager extends (EventEmitter as new () => TypedEmitter<Conditiona
 }
 
 export interface VillagerTrade {
-  firstInput: Item
-  output: Item
-  hasSecondItem: boolean
-  secondaryInput: Item | null
-  disabled: boolean
-  tooluses: number
-  maxTradeuses: number
+  inputItem1: Item
+  outputItem: Item
+  inputItem2: Item | null
+  hasItem2: boolean
+  tradeDisabled: boolean
+  nbTradeUses: number
+  maximumNbTradeUses: number
+  xp?: number
+  specialPrice?: number
+  priceMultiplier?: number
+  demand?: number
+  realPrice?: number
 }
 
 export class ScoreBoard {
@@ -791,7 +783,7 @@ export class Team {
 
   update (name: string, friendlyFire: boolean, nameTagVisibility: string, collisionRule: string, formatting: number, prefix: string, suffix: string): void;
 
-  displayName (member: string);
+  displayName (member: string): ChatMessage;
 }
 
 export type DisplaySlot =