Update player_info handling (PrismarineJS#3689)

* Update player_info handling

* update sound packet for holder

* internal test fixes

* add logging

* cleanup

* revert last change

* Update ci.yml

* Update package.json

---------

Co-authored-by: Romain Beaumont <romain.rom1@gmail.com>

Author: extremeheat

lib/plugins/chat.js

@@ -118,7 +118,7 @@ function inject (bot, options) {
         target: data.targetName ? JSON.parse(data.targetName) : undefined,
         content: message ? JSON.parse(message) : { text: data.plainMessage }
       }
-      const registryIndex = data.type.registryIndex ? data.type.registryIndex : data.type
+      const registryIndex = data.type.chatType != null ? data.type.chatType : data.type
       msg = ChatMessage.fromNetwork(registryIndex, parameters)
 
       if (data.unsignedContent) {

lib/plugins/entities.js

@@ -599,201 +599,139 @@ function inject (bot) {
     bot.emit('entitySpawn', bot.entity)
   })
 
-  bot._client.on('player_info', (packet) => {
-    // player list item(s)
+  function handlePlayerInfoBitfield (packet) {
+    for (const item of packet.data) {
+      let player = bot._playerFromUUID(item.uuid)
+      const newPlayer = !player
 
-    if (typeof packet.action !== 'number') {
-      // the features checks below this will be un-needed with https://github.com/PrismarineJS/minecraft-data/pull/948
-      for (const update of packet.data) {
-        let player = bot.uuidToUsername[update.uuid] ? bot.players[bot.uuidToUsername[update.uuid]] : null
-        let newPlayer = false
-
-        const obj = {
-          uuid: update.uuid
-        }
-
-        if (!player) newPlayer = true
-
-        player ||= obj
-
-        if (packet.action.add_player) {
-          obj.username = update.player.name
-          obj.displayName = player.displayName || new ChatMessage({ text: '', extra: [{ text: update.player.name }] })
-          obj.skinData = extractSkinInformation(update.player.properties)
-        }
-
-        if (packet.action.update_game_mode) {
-          obj.gamemode = update.gamemode
-        }
-
-        if (packet.action.update_latency) {
-          obj.ping = update.latency
-        }
+      if (newPlayer) {
+        player = { uuid: item.uuid }
+      }
 
-        if (update.displayName) {
-          obj.displayName = ChatMessage.fromNotch(update.displayName)
+      if (packet.action.add_player) {
+        player.username = item.player.name
+        player.displayName = new ChatMessage({ text: '', extra: [{ text: item.player.name }] })
+        player.skinData = extractSkinInformation(item.player.properties)
+      }
+      if (packet.action.initialize_chat && item.chatSession) {
+        player.chatSession = {
+          publicKey: item.chatSession.publicKey,
+          sessionUuid: item.chatSession.uuid
         }
+      }
+      if (packet.action.update_game_mode) {
+        player.gamemode = item.gamemode
+      }
+      if (packet.action.update_listed) {
+        player.listed = item.listed
+      }
+      if (packet.action.update_latency) {
+        player.ping = item.latency
+      }
+      if (packet.action.update_display_name) {
+        player.displayName = item.displayName ? ChatMessage.fromNotch(item.displayName) : new ChatMessage({ text: '', extra: [{ text: player.username }] })
+      }
 
-        if (newPlayer) {
-          if (!obj.username) continue // Should be unreachable
-          player = bot.players[obj.username] = obj
-          bot.uuidToUsername[obj.uuid] = obj.username
-        } else {
-          Object.assign(player, obj)
-        }
+      if (newPlayer) {
+        if (!player.username) continue // Should be unreachable if add_player is always sent for new players
+        bot.players[player.username] = player
+        bot.uuidToUsername[player.uuid] = player.username
+      }
 
-        const playerEntity = Object.values(bot.entities).find(e => e.type === 'player' && e.username === player.username)
-        player.entity = playerEntity
+      const playerEntity = Object.values(bot.entities).find(e => e.type === 'player' && e.username === player.username)
+      player.entity = playerEntity
 
-        if (playerEntity === bot.entity) {
-          bot.player = player
-        }
+      if (playerEntity === bot.entity) {
+        bot.player = player
+      }
 
-        if (newPlayer) {
-          bot.emit('playerJoined', player)
-        } else {
-          bot.emit('playerUpdated', player)
-        }
+      if (newPlayer) {
+        bot.emit('playerJoined', player)
+      } else {
+        bot.emit('playerUpdated', player)
       }
-      return
     }
+  }
 
-    if (bot.supportFeature('playerInfoActionIsBitfield')) {
-      for (const item of packet.data) {
-        let player = bot.uuidToUsername[item.uuid] ? bot.players[bot.uuidToUsername[item.uuid]] : null
-        let newPlayer = false
-
-        const obj = {
-          uuid: item.uuid
-        }
-
-        if (!player) newPlayer = true
-
-        player = player || obj
-
-        if (packet.action & 1) {
-          obj.username = item.player.name
-          obj.displayName = player.displayName || new ChatMessage({ text: '', extra: [{ text: item.player.name }] })
-          obj.skinData = extractSkinInformation(item.player.properties)
-        }
-
-        if (packet.action & 4) {
-          obj.gamemode = item.gamemode
-        }
-
-        if (packet.action & 16) {
-          obj.ping = item.latency
-        }
-
-        if (item.displayName) {
-          obj.displayName = ChatMessage.fromNotch(item.displayName)
-        } else if (packet.action & 32) obj.displayName = new ChatMessage({ text: '', extra: [{ text: player.username || obj.username }] })
-
-        if (newPlayer) {
-          if (!obj.username) continue // Should be unreachable
-          player = bot.players[obj.username] = obj
-          bot.uuidToUsername[obj.uuid] = obj.username
-        } else {
-          Object.assign(player, obj)
-        }
-
-        const playerEntity = Object.values(bot.entities).find(e => e.type === 'player' && e.username === player.username)
-        player.entity = playerEntity
-
-        if (playerEntity === bot.entity) {
-          bot.player = player
-        }
-
-        if (newPlayer) {
-          bot.emit('playerJoined', player)
-        } else {
-          bot.emit('playerUpdated', player)
-        }
-      }
-    } else {
-      for (const item of packet.data) {
-        let player = bot.uuidToUsername[item.UUID] ? bot.players[bot.uuidToUsername[item.UUID]] : null
-        if (packet.action === 0) {
-          let newPlayer = false
+  function handlePlayerInfoLegacy (packet) {
+    for (const item of packet.data) {
+      let player = bot._playerFromUUID(item.uuid)
 
-          // New Player
-          if (!player) {
+      switch (packet.action) {
+        case 'add_player': {
+          const newPlayer = !player
+          if (newPlayer) {
             player = bot.players[item.name] = {
               username: item.name,
-              ping: item.ping,
-              uuid: item.UUID,
-              displayName: new ChatMessage({ text: '', extra: [{ text: item.name }] }),
-              skinData: extractSkinInformation(item.properties),
-              profileKeys: item.crypto
-                ? {
-                    publicKey: item.crypto.publicKey, // DER-encoded public key
-                    signature: item.crypto.signature // Signature
-                  }
-                : null
+              uuid: item.uuid
             }
+            bot.uuidToUsername[item.uuid] = item.name
+          }
 
-            bot.uuidToUsername[item.UUID] = item.name
-            bot.emit('playerJoined', player)
-            newPlayer = true
-          } else {
-            // Just an Update
-            player.gamemode = item.gamemode
-            player.ping = item.ping
+          player.ping = item.ping
+          player.gamemode = item.gamemode
+          player.displayName = item.displayName ? ChatMessage.fromNotch(item.displayName) : new ChatMessage({ text: '', extra: [{ text: item.name }] })
+          if (item.properties) {
             player.skinData = extractSkinInformation(item.properties)
-            if (item.crypto) {
-              player.profileKeys = {
-                publicKey: item.crypto.publicKey,
-                signature: item.crypto.signature
-              }
-            }
           }
-
-          if (item.displayName) {
-            player.displayName = ChatMessage.fromNotch(item.displayName)
+          if (item.crypto) {
+            player.profileKeys = {
+              publicKey: item.crypto.publicKey,
+              signature: item.crypto.signature
+            }
           }
 
           const playerEntity = Object.values(bot.entities).find(e => e.type === 'player' && e.username === item.name)
           player.entity = playerEntity
-
           if (playerEntity === bot.entity) {
             bot.player = player
           }
 
-          if (!newPlayer) {
+          if (newPlayer) bot.emit('playerJoined', player)
+          else bot.emit('playerUpdated', player)
+          break
+        }
+        case 'update_gamemode': {
+          if (player) {
+            player.gamemode = item.gamemode
             bot.emit('playerUpdated', player)
           }
-        } else if (player) {
-          if (packet.action === 1) {
-            player.gamemode = item.gamemode
-          } else if (packet.action === 2) {
+          break
+        }
+        case 'update_latency': {
+          if (player) {
             player.ping = item.ping
-          } else if (packet.action === 3 && !item.displayName) {
-            player.displayName = new ChatMessage({ text: '', extra: [{ text: player.username }] })
-          } else if (packet.action === 3 && item.displayName) {
-            player.displayName = ChatMessage.fromNotch(item.displayName)
-          } else if (packet.action === 4) {
+            bot.emit('playerUpdated', player)
+          }
+          break
+        }
+        case 'update_display_name': {
+          if (player) {
+            player.displayName = item.displayName ? ChatMessage.fromNotch(item.displayName) : new ChatMessage({ text: '', extra: [{ text: player.username }] })
+            bot.emit('playerUpdated', player)
+          }
+          break
+        }
+        case 'remove_player': {
+          if (player) {
             if (player.entity === bot.entity) continue
-
             player.entity = null
             delete bot.players[player.username]
-            delete bot.uuidToUsername[item.UUID]
+            delete bot.uuidToUsername[item.uuid]
             bot.emit('playerLeft', player)
-            continue
-          } else {
-            continue
           }
-
-          bot.emit('playerUpdated', player)
+          break
         }
       }
     }
-  })
+  }
 
-  // (1.19.3) player(s) leave the game
+  bot._client.on('player_info', bot.supportFeature('playerInfoActionIsBitfield') ? handlePlayerInfoBitfield : handlePlayerInfoLegacy)
+
+  // 1.19.3+ - player(s) leave the game
   bot._client.on('player_remove', (packet) => {
     for (const uuid of packet.players) {
-      const player = bot.uuidToUsername[uuid] ? bot.players[bot.uuidToUsername[uuid]] : null
-
+      const player = bot._playerFromUUID(uuid)
       if (!player || player.entity === bot.entity) continue
 
       player.entity = null

lib/plugins/physics.js

@@ -354,38 +354,36 @@ function inject (bot, { physicsEnabled, maxCatchupTicks }) {
     // e.g. when crouching/crawling/swimming. Can someone confirm?
     bot.entity.height = 1.8
 
-    // Velocity is reset if the x, y, z flags are not set
     const vel = bot.entity.velocity
-    // If the x, y, z flags are not set, the position is absolute
     const pos = bot.entity.position
-
-    // TODO: this current mineflayer logic maybe incorrect. New (maybe even older) versions of minecraft have flag values for
-    // dx/dy/dz but mineflayer is assuming that 0b111 applies for both velocity and position.
-
     let newYaw, newPitch
 
-    if (bot.registry.version['>=']('1.21.3')) {
-      // flags is now an object with keys
-      // "flags": ["x", "y", "z", "yaw", "pitch", "dx", "dy", "dz", "yawDelta"]
-      const flags = packet.flags
+    // Note: 1.20.5+ uses a bitflags object, older versions use a bitmask number
+    if (typeof packet.flags === 'object') {
+      // Modern path with bitflags object
+      // Velocity is only set to 0 if the flag is not set, otherwise keep current velocity
       vel.set(
-        flags.x ? vel.x : 0,
-        flags.y ? vel.y : 0,
-        flags.z ? vel.z : 0
+        packet.flags.x ? vel.x : 0,
+        packet.flags.y ? vel.y : 0,
+        packet.flags.z ? vel.z : 0
       )
+      // If flag is set, then the corresponding value is relative, else it is absolute
       pos.set(
-        flags.x ? (pos.x + packet.x) : packet.x,
-        flags.y ? (pos.y + packet.y) : packet.y,
-        flags.z ? (pos.z + packet.z) : packet.z
+        packet.flags.x ? (pos.x + packet.x) : packet.x,
+        packet.flags.y ? (pos.y + packet.y) : packet.y,
+        packet.flags.z ? (pos.z + packet.z) : packet.z
       )
-      newYaw = (flags.yaw ? conv.toNotchianYaw(bot.entity.yaw) : 0) + packet.yaw
-      newPitch = (flags.pitch ? conv.toNotchianPitch(bot.entity.pitch) : 0) + packet.pitch
+      newYaw = (packet.flags.yaw ? conv.toNotchianYaw(bot.entity.yaw) : 0) + packet.yaw
+      newPitch = (packet.flags.pitch ? conv.toNotchianPitch(bot.entity.pitch) : 0) + packet.pitch
     } else {
+      // Legacy path with bitmask number
+      // Velocity is only set to 0 if the flag is not set, otherwise keep current velocity
       vel.set(
         packet.flags & 1 ? vel.x : 0,
         packet.flags & 2 ? vel.y : 0,
         packet.flags & 4 ? vel.z : 0
       )
+      // If flag is set, then the corresponding value is relative, else it is absolute
       pos.set(
         packet.flags & 1 ? (pos.x + packet.x) : packet.x,
         packet.flags & 2 ? (pos.y + packet.y) : packet.y,

lib/plugins/ray_trace.js

@@ -11,7 +11,6 @@ module.exports = (bot) => {
   }
 
   bot.blockInSight = (maxSteps = 256, vectorLength = 5 / 16) => {
-    console.warn('[deprecated] use bot.blockAtCursor instead')
     const block = bot.blockAtCursor(maxSteps * vectorLength)
     if (block) return block
   }