clean up code

bedrock-crustaceans · Aug 3, 2024 · bd1efd9 · bd1efd9
1 parent f56bf95
commit bd1efd9
Show file tree

Hide file tree

Showing 11 changed files with 35 additions and 62 deletions.
diff --git a/crates/nbt/src/lib.rs b/crates/nbt/src/lib.rs
@@ -413,30 +413,14 @@ impl NbtTag {
                 let mut map = HashMap::new();
 
                 loop {
-                    let id = match T::read_u8(stream) {
-                        Ok(v) => v,
-                        Err(e) => {
-                            return Err(e);
-                        }
-                    };
+                    let id = T::read_u8(stream)?;
 
                     if id == Self::EMPTY_ID {
                         break;
                     }
 
-                    let key = match T::read_string(stream) {
-                        Ok(v) => v,
-                        Err(e) => {
-                            return Err(e);
-                        }
-                    };
-
-                    let tag = match Self::nbt_deserialize_val::<T>(stream, id) {
-                        Ok(v) => v,
-                        Err(e) => {
-                            return Err(e);
-                        }
-                    };
+                    let key = T::read_string(stream)?;
+                    let tag = Self::nbt_deserialize_val::<T>(stream, id)?;
 
                     map.insert(key, tag);
                 }

diff --git a/crates/paletted_storage/src/lib.rs b/crates/paletted_storage/src/lib.rs
@@ -6,7 +6,7 @@ use bedrockrs_nbt::endian::little_endian_network::NbtLittleEndianNetwork;
 use bedrockrs_nbt::NbtTag;
 use byteorder::ReadBytesExt;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct PalettedStorage {
     pub blocks: [u32; 4096],
     pub palette: Vec<NbtTag>,

diff --git a/crates/proto/src/compression.rs b/crates/proto/src/compression.rs
@@ -30,7 +30,7 @@ impl Compression {
         match self {
             Compression::Zlib { .. } => 0x00,
             Compression::Snappy { .. } => 0x01,
-            Compression::None => 0xFF,
+            Compression::None => u8::MAX,
         }
     }
 
@@ -41,7 +41,7 @@ impl Compression {
         match self {
             Compression::Zlib { .. } => 0x0000,
             Compression::Snappy { .. } => 0x0001,
-            Compression::None => 0xFFFF,
+            Compression::None => u16::MAX,
         }
     }
 
@@ -62,7 +62,7 @@ impl Compression {
         match self {
             Compression::Zlib { threshold, .. } => *threshold,
             Compression::Snappy { threshold, .. } => *threshold,
-            Compression::None => 0x0000,
+            Compression::None => 0,
         }
     }
 

diff --git a/crates/proto/src/connection.rs b/crates/proto/src/connection.rs
@@ -129,8 +129,10 @@ impl Connection {
                     Err(_) => {}
                 };
 
+                let pos = decrypted_stream.position() as usize;
+
                 compression
-                    .decompress(decrypted_stream.into_inner(), &mut decompressed_stream)
+                    .decompress(&decrypted_stream.into_inner()[pos..], &mut decompressed_stream)
                     .map_err(|e| ConnectionError::CompressError(e))?;
 
                 Cursor::new(decompressed_stream.as_slice())

diff --git a/crates/proto/src/gamepacket.rs b/crates/proto/src/gamepacket.rs
@@ -846,24 +846,13 @@ impl GamePacket {
         // Read the game packet length
         // We don't need it, yet?
         // TODO: Use this to possibly async the packet handling
-        match VAR::<u32>::read(stream) {
-            Ok(_) => {}
-            Err(e) => return Err(ProtoCodecError::IOError(Arc::new(e))),
-        };
+        VAR::<u32>::proto_deserialize(stream)?;
 
         // Read the game packet header and parse it into an u16
-        let game_packet_header: u16 = match VAR::<u32>::read(stream) {
-            Ok(v) => match v.into_inner().try_into() {
-                Ok(v) => v,
-                Err(e) => {
-                    return Err(ProtoCodecError::FromIntError(e));
-                }
-            },
-            Err(e) => return Err(ProtoCodecError::IOError(Arc::new(e))),
-        };
+        let game_packet_header: u16 = VAR::<u32>::proto_deserialize(stream)?.into_inner().try_into().map_err(ProtoCodecError::FromIntError)?;
 
         // Get the first 10 bits as the packet id
-        // Can never be more than a 16-bit integer due to being 10 bits big
+        // Can never be more than a 16-bit integer due to being 10-bits big
         // Gamepacket IDs through 200-299 are used for spin-offs, they are free to use for custom packets
         let game_packet_id = game_packet_header & 0b0000_0011_1111_1111;
 

diff --git a/crates/proto/src/login/provider/default.rs b/crates/proto/src/login/provider/default.rs
@@ -28,7 +28,9 @@ impl DefaultLoginProvider {
 
 impl LoginProviderServer for DefaultLoginProvider {
     fn compression(&self) -> Compression {
-        Compression::None
+        Compression::Snappy {
+            threshold: 1,
+        }
     }
     fn encryption_enabled(&self) -> bool {
         false

diff --git a/crates/proto/src/packets/level_chunk.rs b/crates/proto/src/packets/level_chunk.rs
@@ -1,12 +1,13 @@
 use crate::types::chunk_pos::ChunkPos;
 use bedrockrs_core::int::{LE, VAR};
+use bedrockrs_proto_core::error::ProtoCodecError;
 use bedrockrs_proto_core::ProtoCodec;
 
 #[derive(Debug, Clone)]
 pub struct LevelChunkPacket {
     pub chunk_position: ChunkPos,
     pub dimension_id: VAR<i32>,
-    pub sub_chunk_count: VAR<i32>,
+    pub sub_chunk_count: VAR<u32>,
     pub cache_enabled: bool,
     pub serialized_chunk_data: Vec<u8>,
 
@@ -26,10 +27,10 @@ impl ProtoCodec for LevelChunkPacket {
             self.sub_chunk_count.proto_serialize(stream)?;
         } else {
             if !(self.client_request_subchunk_limit.into_inner() < 0) {
-                VAR::<u32>::new(0xFFFFFFFE).proto_serialize(stream)?;
+                VAR::<u32>::new(u32::MAX - 1).proto_serialize(stream)?;
                 self.client_request_subchunk_limit.proto_serialize(stream)?;
             } else {
-                VAR::<u32>::new(0xFFFFFFFF).proto_serialize(stream)?;
+                VAR::<u32>::new(u32::MAX).proto_serialize(stream)?;
             }
         }
 
@@ -39,9 +40,18 @@ impl ProtoCodec for LevelChunkPacket {
             unimplemented!()
         }
 
+        let len = self.serialized_chunk_data
+            .len()
+            .try_into()
+            .map_err(ProtoCodecError::FromIntError)?;
+
+        VAR::<u32>::new(len).proto_serialize(stream)?;
+
         stream.extend_from_slice(&self.serialized_chunk_data);
 
-        return Ok(());
+        println!("finish");
+
+        Ok(())
     }
 
     fn proto_deserialize(

diff --git a/crates/proto/src/packets/text_message.rs b/crates/proto/src/packets/text_message.rs
@@ -134,16 +134,12 @@ impl ProtoCodec for TextMessagePacket {
     }
 
     fn proto_deserialize(stream: &mut Cursor<&[u8]>) -> Result<Self, ProtoCodecError> {
-        println!("#0");
         let message_type = u8::proto_deserialize(stream)?;
-
-        println!("#1");
         let localize = bool::proto_deserialize(stream)?;
 
         let message_type = match message_type {
             0 => TextMessageData::Raw(String::proto_deserialize(stream)?),
             1 => {
-                println!("#2");
                 TextMessageData::Chat {
                     player_name: String::proto_deserialize(stream)?,
                     message: String::proto_deserialize(stream)?,
@@ -224,11 +220,8 @@ impl ProtoCodec for TextMessagePacket {
             }
         };
 
-        println!("#3");
         let sender_xuid = String::proto_deserialize(stream)?;
-        println!("#4");
         let platform_id = String::proto_deserialize(stream)?;
-        println!("#5");
         let filtered_message = String::proto_deserialize(stream)?;
 
         Ok(Self {

diff --git a/crates/proto/src/types/connection_request.rs b/crates/proto/src/types/connection_request.rs
@@ -100,13 +100,10 @@ impl ProtoCodec for ConnectionRequest {
         // (certificate_chain len + raw_token len + 8)
         // 8 = i32 len + i32 len (length of certificate_chain's len and raw_token's len)
         // can be ignored, other lengths are provided
-        VAR::<u32>::read(stream).map_err(|e| ProtoCodecError::IOError(Arc::new(e)))?;
+        VAR::<u32>::proto_deserialize(stream)?;
 
         // read length of certificate_chain vec
-        let certificate_chain_len = match LE::<i32>::read(stream) {
-            Ok(l) => l.into_inner(),
-            Err(e) => return Err(ProtoCodecError::IOError(Arc::new(e))),
-        };
+        let certificate_chain_len = LE::<i32>::proto_deserialize(stream)?.into_inner();
 
         let certificate_chain_len = certificate_chain_len
             .try_into()

diff --git a/crates/proto/src/types/gamerule.rs b/crates/proto/src/types/gamerule.rs
@@ -52,14 +52,10 @@ impl ProtoCodec for GameRuleValue {
             {
                 1 => GameRuleValue::ValBool(bool::proto_deserialize(stream)?),
                 2 => GameRuleValue::ValVarU32(
-                    VAR::<u32>::read(stream)
-                        .map_err(|e| ProtoCodecError::IOError(Arc::new(e)))?
-                        .into_inner(),
+                    VAR::<u32>::proto_deserialize(stream)?.into_inner(),
                 ),
                 3 => GameRuleValue::ValF32(
-                    LE::<f32>::read(stream)
-                        .map_err(|e| ProtoCodecError::IOError(Arc::new(e)))?
-                        .into_inner(),
+                    LE::<f32>::proto_deserialize(stream)?.into_inner(),
                 ),
                 other => {
                     return Err(ProtoCodecError::InvalidEnumID(

diff --git a/crates/world/src/world_db/subchunk.rs b/crates/world/src/world_db/subchunk.rs
@@ -3,7 +3,7 @@ use std::io::Cursor;
 use bedrockrs_paletted_storage::PalettedStorage;
 use byteorder::ReadBytesExt;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct SubChunk {
     pub paletted_storage: Vec<PalettedStorage>,
 }