diff --git a/pumpkin-protocol/src/codec/bitset.rs b/pumpkin-protocol/src/codec/bitset.rs
index f478265dc..11808a9c6 100644
--- a/pumpkin-protocol/src/codec/bitset.rs
+++ b/pumpkin-protocol/src/codec/bitset.rs
@@ -36,13 +36,13 @@ impl<const N: usize> PacketRead for Bitset<N> {
     fn read<R: Read>(reader: &mut R) -> Result<Self, Error> {
         let mut bitset = Self::default();
 
-        for i in 0..N.div_ceil(8) {
+        for i in 0..N.div_ceil(7) {
             let byte = u8::read(reader)?;
             bitset.bits |= (u128::from(byte) & 0x7F) << (i * 7);
             if byte & 0x80 == 0 {
                 return Ok(bitset);
             }
         }
-        Err(Error::new(ErrorKind::InvalidData, ""))
+        Err(Error::new(ErrorKind::InvalidData, "Bitset too large"))
     }
 }
diff --git a/pumpkin/src/net/bedrock/mod.rs b/pumpkin/src/net/bedrock/mod.rs
index bada9794a..2cff88d91 100644
--- a/pumpkin/src/net/bedrock/mod.rs
+++ b/pumpkin/src/net/bedrock/mod.rs
@@ -512,34 +512,41 @@ impl BedrockClient {
         server: &Arc<Server>,
         packet: RawPacket,
     ) -> Result<(), Error> {
+        let packet_id = packet.id;
         let payload = &mut Cursor::new(&packet.payload);
-        match packet.id {
+        let result = match packet.id {
             SRequestNetworkSettings::PACKET_ID => {
                 self.handle_request_network_settings(SRequestNetworkSettings::read(payload)?)
                     .await;
+                Ok(())
             }
             SLogin::PACKET_ID => {
                 self.handle_login(SLogin::read(payload)?, server).await;
+                Ok(())
             }
             SClientCacheStatus::PACKET_ID => {
                 // TODO
+                Ok(())
             }
             SResourcePackResponse::PACKET_ID => {
                 self.handle_resource_pack_response(SResourcePackResponse::read(payload)?, server)
                     .await;
+                Ok(())
             }
             _ => {
                 let player_lock = self.player.lock().await;
                 if let Some(player) = player_lock.as_ref() {
-                    return self.handle_play_packet(player, server, packet).await;
+                    self.handle_play_packet(player, server, packet).await
+                } else {
+                    debug!(
+                        "Received game packet {} before player was initialized",
+                        packet.id
+                    );
+                    Ok(())
                 }
-                debug!(
-                    "Received game packet {} before player was initialized",
-                    packet.id
-                );
             }
-        }
-        Ok(())
+        };
+        result.map_err(|e| Error::new(e.kind(), format!("Game packet {packet_id}: {e}")))
     }
 
     pub async fn handle_play_packet(