Anvil: Added LV4 Compression

Pumpkin-MC · Oct 14, 2024 · 3eacf1e · 3eacf1e
1 parent df80ac2
commit 3eacf1e
Show file tree

Hide file tree

Showing 6 changed files with 62 additions and 24 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/pumpkin-world/Cargo.toml b/pumpkin-world/Cargo.toml
@@ -14,7 +14,12 @@ derive_more.workspace = true
 itertools.workspace = true
 thiserror = "1.0"
 futures = "0.3"
+
+
+# Compression
 flate2 = "1.0"
+lz4 = "1.11.1"
+
 serde.workspace = true
 serde_json = "1.0"
 log.workspace = true

diff --git a/pumpkin-world/src/chunk/anvil.rs b/pumpkin-world/src/chunk/anvil.rs
@@ -26,41 +26,60 @@ impl AnvilChunkReader {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Compression {
-    Gzip,
-    Zlib,
+    /// GZip Compression
+    GZip,
+    /// ZLib Compression
+    ZLib,
+    /// Uncompressed (since a version before 1.15.1)
     None,
+    /// LZ4 Compression (since 24w04a)
     LZ4,
+    /// Custom compression algorithm (since 24w05a)
+    Custom,
 }
 
 impl Compression {
     pub fn from_byte(byte: u8) -> Option<Self> {
         match byte {
-            1 => Some(Self::Gzip),
-            2 => Some(Self::Zlib),
+            1 => Some(Self::GZip),
+            2 => Some(Self::ZLib),
             3 => Some(Self::None),
             4 => Some(Self::LZ4),
+            // Creative i guess?
+            127 => Some(Self::Custom),
             _ => None,
         }
     }
 
     fn decompress_data(&self, compressed_data: Vec<u8>) -> Result<Vec<u8>, CompressionError> {
         match self {
-            Compression::Gzip => {
-                let mut z = GzDecoder::new(&compressed_data[..]);
-                let mut chunk_data = Vec::with_capacity(compressed_data.len());
-                z.read_to_end(&mut chunk_data)
+            Compression::GZip => {
+                let mut decoder = GzDecoder::new(&compressed_data[..]);
+                let mut chunk_data = Vec::new();
+                decoder
+                    .read_to_end(&mut chunk_data)
                     .map_err(CompressionError::GZipError)?;
                 Ok(chunk_data)
             }
-            Compression::Zlib => {
-                let mut z = ZlibDecoder::new(&compressed_data[..]);
-                let mut chunk_data = Vec::with_capacity(compressed_data.len());
-                z.read_to_end(&mut chunk_data)
+            Compression::ZLib => {
+                let mut decoder = ZlibDecoder::new(&compressed_data[..]);
+                let mut chunk_data = Vec::new();
+                decoder
+                    .read_to_end(&mut chunk_data)
                     .map_err(CompressionError::ZlibError)?;
                 Ok(chunk_data)
             }
             Compression::None => Ok(compressed_data),
-            Compression::LZ4 => todo!(),
+            Compression::LZ4 => {
+                let mut decoder = lz4::Decoder::new(compressed_data.as_slice())
+                    .map_err(CompressionError::LZ4Error)?;
+                let mut decompressed_data = Vec::new();
+                decoder
+                    .read_to_end(&mut decompressed_data)
+                    .map_err(CompressionError::LZ4Error)?;
+                Ok(decompressed_data)
+            }
+            Compression::Custom => todo!(),
         }
     }
 }

diff --git a/pumpkin-world/src/chunk/mod.rs b/pumpkin-world/src/chunk/mod.rs
@@ -50,6 +50,8 @@ pub enum CompressionError {
     ZlibError(std::io::Error),
     #[error("Error while working with Gzip compression: {0}")]
     GZipError(std::io::Error),
+    #[error("Error while working with LZ4 compression: {0}")]
+    LZ4Error(std::io::Error),
 }
 
 pub struct ChunkData {

diff --git a/pumpkin-world/src/level.rs b/pumpkin-world/src/level.rs
@@ -3,7 +3,6 @@ use std::{collections::HashMap, path::PathBuf, sync::Arc};
 use parking_lot::Mutex;
 use pumpkin_core::math::vector2::Vector2;
 use rayon::prelude::*;
-use thiserror::Error;
 use tokio::sync::mpsc;
 
 use crate::{
@@ -33,9 +32,6 @@ pub struct SaveFile {
     pub region_folder: PathBuf,
 }
 
-#[derive(Error, Debug)]
-pub enum WorldError {}
-
 impl Level {
     pub fn from_root_folder(root_folder: PathBuf) -> Self {
         let world_gen = get_world_gen(Seed(0)); // TODO Read Seed from config.
@@ -79,7 +75,7 @@ impl Level {
     pub fn fetch_chunks(
         &self,
         chunks: &[Vector2<i32>],
-        channel: mpsc::Sender<Result<Arc<ChunkData>, WorldError>>,
+        channel: mpsc::Sender<Arc<ChunkData>>,
         is_alive: bool,
     ) {
         chunks.into_par_iter().for_each(|at| {
@@ -92,7 +88,7 @@ impl Level {
             // Check if chunks is already loaded
             if loaded_chunks.contains_key(at) {
                 channel
-                    .blocking_send(Ok(loaded_chunks.get(at).unwrap().clone()))
+                    .blocking_send(loaded_chunks.get(at).unwrap().clone())
                     .expect("Failed sending ChunkData.");
                 return;
             }
@@ -116,7 +112,7 @@ impl Level {
             .unwrap();
             let data = Arc::new(data);
             channel
-                .blocking_send(Ok(data.clone()))
+                .blocking_send(data.clone())
                 .expect("Failed sending ChunkData.");
             loaded_chunks.insert(at, data);
         })

diff --git a/pumpkin/src/world/mod.rs b/pumpkin/src/world/mod.rs
@@ -235,10 +235,6 @@ impl World {
 
         while let Some(chunk_data) = chunk_receiver.recv().await {
             // dbg!(chunk_pos);
-            let chunk_data = match chunk_data {
-                Ok(d) => d,
-                Err(_) => continue,
-            };
             #[cfg(debug_assertions)]
             if chunk_data.position == (0, 0).into() {
                 use pumpkin_protocol::bytebuf::ByteBuffer;