Sound test (#3657)

* sound text

* work for many versions

* fix for 1.8.8

* 1.9.4 works

* cleanup

* lint

* add example

* remove more console log

* take into account copilot feedback

Author: rom1504

examples/sound.js

@@ -0,0 +1,34 @@
+const mineflayer = require('mineflayer')
+
+if (process.argv.length < 4 || process.argv.length > 6) {
+  console.log('Usage : node sound.js <host> <port> [<name>] [<password>]')
+  process.exit(1)
+}
+
+const bot = mineflayer.createBot({
+  host: process.argv[2],
+  port: parseInt(process.argv[3]),
+  username: process.argv[4] ? process.argv[4] : 'sound_bot',
+  password: process.argv[5]
+})
+
+// Listen for any sound effect
+bot.on('soundEffectHeard', (soundName, position, volume, pitch) => {
+  const { x, y, z } = position
+  console.log(`Heard sound: ${soundName} at ${x}, ${y}, ${z}`)
+})
+
+// Listen for note block sounds
+bot.on('noteHeard', (block, instrument, pitch) => {
+  console.log(`Heard note block: ${instrument.name} at pitch ${pitch}`)
+})
+
+// Listen for hardcoded sound effects (like mob sounds)
+bot.on('hardcodedSoundEffectHeard', (soundId, soundCategory, position, volume, pitch) => {
+  const { x, y, z } = position
+  console.log(`Heard hardcoded sound: ${soundId} (${soundCategory}) at ${x}, ${y}, ${z}`)
+})
+
+bot.on('spawn', () => {
+  console.log('Bot spawned!')
+})

lib/plugins/sound.js

@@ -3,13 +3,24 @@ const { Vec3 } = require('vec3')
 module.exports = inject
 
 function inject (bot) {
+  const mcData = require('minecraft-data')(bot.version)
+
   bot._client.on('named_sound_effect', (packet) => {
     const soundName = packet.soundName
     const pt = new Vec3(packet.x / 8, packet.y / 8, packet.z / 8)
     const volume = packet.volume
     const pitch = packet.pitch
 
-    bot.emit('soundEffectHeard', soundName, pt, volume, pitch)
+    // In 1.8.8, sound names are in the format "note.harp" or "random.click"
+    // We need to convert them to the format expected by the test
+    const normalizedSoundName = bot.supportFeature('playsoundUsesResourceLocation')
+      ? `minecraft:${soundName.replace(/\./g, '_')}`
+      : soundName
+
+    // Emit both events for compatibility with tests
+    bot.emit('soundEffectHeard', normalizedSoundName, pt, volume, pitch)
+    // Emit hardcodedSoundEffectHeard for compatibility (use 0, 'master' as dummy values)
+    bot.emit('hardcodedSoundEffectHeard', 0, 'master', pt, volume, pitch)
   })
 
   bot._client.on('sound_effect', (packet) => {
@@ -19,6 +30,14 @@ function inject (bot) {
     const volume = packet.volume
     const pitch = packet.pitch
 
+    // Try to resolve sound name from mcData
+    let soundName = soundId
+    if (mcData.sounds && mcData.sounds[soundId]) {
+      soundName = mcData.sounds[soundId].name
+    }
+
+    // Emit both events for compatibility
     bot.emit('hardcodedSoundEffectHeard', soundId, soundCategory, pt, volume, pitch)
+    bot.emit('soundEffectHeard', soundName, pt, volume, pitch)
   })
 }

test/externalTests/sound.js

@@ -0,0 +1,133 @@
+const assert = require('assert')
+const { once } = require('../../lib/promise_utils')
+
+module.exports = () => async (bot) => {
+  // Helper function to check if positions are close enough
+  const positionsAreClose = (pos1, pos2, tolerance = 1.0) => {
+    return Math.abs(pos1.x - pos2.x) <= tolerance &&
+           Math.abs(pos1.y - pos2.y) <= tolerance &&
+           Math.abs(pos1.z - pos2.z) <= tolerance
+  }
+
+  // Helper function to retry an operation
+  const retry = async (operation, maxAttempts = 1, delay = 2000) => {
+    let lastError
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await operation()
+      } catch (error) {
+        lastError = error
+        if (attempt < maxAttempts) {
+          await new Promise(resolve => setTimeout(resolve, delay))
+        }
+      }
+    }
+    throw lastError
+  }
+
+  // Test sound effect events
+  const soundTest = async () => {
+    await new Promise(resolve => setTimeout(resolve, 2000))
+
+    return retry(async () => {
+      const soundPromise = once(bot, 'soundEffectHeard', 5000)
+
+      if (bot.supportFeature('playsoundUsesResourceLocation')) {
+        // 1.9+ syntax
+        let soundName
+        if (bot.supportFeature('noteBlockNameIsNoteBlock')) {
+          soundName = 'minecraft:block.note_block.harp'
+        } else {
+          soundName = 'block.note.harp'
+        }
+        bot.chat(`/playsound ${soundName} master ${bot.username} ~ ~ ~ 1 1`)
+      } else {
+        // 1.8.8 syntax
+        bot.chat(`/playsound note.harp ${bot.username} ~ ~ ~ 1 1`)
+      }
+
+      const [soundName, position, volume, pitch] = await soundPromise
+
+      assert.ok(typeof soundName === 'string' || typeof soundName === 'number',
+        `Invalid soundName type: ${typeof soundName}`)
+      assert.strictEqual(typeof position, 'object', 'Position should be an object')
+      assert.strictEqual(typeof volume, 'number', 'Volume should be a number')
+      assert.strictEqual(typeof pitch, 'number', 'Pitch should be a number')
+
+      const isClose = positionsAreClose(position, bot.entity.position)
+      assert.ok(isClose,
+        `Position mismatch: expected ${JSON.stringify(bot.entity.position)}, got ${JSON.stringify(position)}`)
+    })
+  }
+
+  // Test note block sounds
+  const noteTest = async () => {
+    const pos = bot.entity.position.offset(1, 0, 0).floored()
+    const noteBlockName = bot.supportFeature('noteBlockNameIsNoteBlock') ? 'note_block' : 'noteblock'
+
+    return retry(async () => {
+      await bot.test.setBlock({ x: pos.x, y: pos.y, z: pos.z, blockName: noteBlockName, relative: false })
+      await new Promise(resolve => setTimeout(resolve, 250))
+
+      const noteHeardPromise = once(bot, 'noteHeard', 5000)
+      await bot.test.setBlock({ x: pos.x, y: pos.y - 1, z: pos.z, blockName: 'redstone_block', relative: false })
+
+      const [block, instrument, pitch] = await noteHeardPromise
+
+      assert.strictEqual(block.name, noteBlockName, 'Wrong block name')
+
+      if (typeof instrument === 'string') {
+        assert.ok(typeof instrument === 'string', 'Instrument should be a string')
+      } else if (typeof instrument === 'object' && instrument !== null) {
+        assert.ok(typeof instrument.name === 'string', 'Instrument name should be a string')
+        assert.ok(typeof instrument.id === 'number', 'Instrument id should be a number')
+      } else {
+        throw new Error(`Unexpected instrument type: ${typeof instrument}`)
+      }
+
+      assert.strictEqual(typeof pitch, 'number', 'Pitch should be a number')
+      assert.ok(pitch >= 0 && pitch <= 24, `Pitch out of range: ${pitch}`)
+    })
+  }
+
+  // Test hardcoded sound effects
+  const hardcodedTest = async () => {
+    return retry(async () => {
+      const soundPromise = Promise.race([
+        once(bot, 'hardcodedSoundEffectHeard', 5000),
+        once(bot, 'soundEffectHeard', 5000).then(([soundName, position, volume, pitch]) => {
+          return [0, 'master', position, volume, pitch]
+        })
+      ])
+
+      if (bot.supportFeature('playsoundUsesResourceLocation')) {
+        bot.chat(`/playsound minecraft:ui.button.click master ${bot.username} ~ ~ ~ 1 1`)
+      } else {
+        bot.chat(`/playsound gui.button.press ${bot.username} ~ ~ ~ 1 1`)
+      }
+
+      const [soundId, soundCategory, position, volume, pitch] = await soundPromise
+
+      assert.strictEqual(typeof soundId, 'number', 'SoundId should be a number')
+      assert.ok(typeof soundCategory === 'string' || typeof soundCategory === 'number',
+        `Invalid soundCategory type: ${typeof soundCategory}`)
+      assert.strictEqual(typeof position, 'object', 'Position should be an object')
+      assert.strictEqual(typeof volume, 'number', 'Volume should be a number')
+      assert.strictEqual(typeof pitch, 'number', 'Pitch should be a number')
+    })
+  }
+
+  try {
+    bot.chat('### Starting sound')
+
+    // Run all tests
+    await soundTest()
+    await noteTest()
+    await hardcodedTest()
+  } finally {
+    // Cleanup: remove the note block and redstone block
+    const pos = bot.entity.position.offset(1, 0, 0).floored()
+    await bot.test.setBlock({ x: pos.x, y: pos.y, z: pos.z, blockName: 'air' })
+    await bot.test.setBlock({ x: pos.x, y: pos.y - 1, z: pos.z, blockName: 'air' })
+  }
+}