refactor: simplify chunk data processing in Anvil and Linear serializers

Pumpkin-MC · Feb 20, 2025 · 8cd5352 · 8cd5352
1 parent 9a5c4d7
commit 8cd5352
Show file tree

Hide file tree

Showing 2 changed files with 37 additions and 58 deletions.
diff --git a/pumpkin-world/src/chunk/anvil.rs b/pumpkin-world/src/chunk/anvil.rs
@@ -5,7 +5,6 @@ use pumpkin_config::ADVANCED_CONFIG;
 use pumpkin_nbt::serializer::to_bytes;
 use pumpkin_util::math::ceil_log2;
 use pumpkin_util::math::vector2::Vector2;
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 
 use std::{
     collections::HashSet,
@@ -330,16 +329,9 @@ impl ChunkSerializer for AnvilChunkFile {
     }
 
     fn add_chunks_data(&mut self, chunks_data: &[&Self::Data]) -> Result<(), ChunkWritingError> {
-        let chunks = chunks_data
-            .par_iter()
-            .map(|chunk| {
-                let chunk_index = Self::get_chunk_index(&chunk.position);
-                (chunk_index, chunk)
-            })
-            .collect::<Vec<_>>();
-
-        for (chunk_index, chunk_data) in chunks {
-            self.chunks_data[chunk_index] = Some(AnvilChunkData::from_chunk(chunk_data)?);
+        for chunk in chunks_data {
+            let index = AnvilChunkFile::get_chunk_index(&chunk.position);
+            self.chunks_data[index] = Some(AnvilChunkData::from_chunk(chunk)?);
         }
 
         Ok(())
@@ -349,25 +341,21 @@ impl ChunkSerializer for AnvilChunkFile {
         &self,
         chunks: &[Vector2<i32>],
     ) -> Vec<LoadedData<Self::Data, ChunkReadingError>> {
-        let chunks = chunks
-            .par_iter()
-            .map(|chunk| (Self::get_chunk_index(chunk), *chunk))
-            .collect::<Vec<_>>();
-
-        let mut fetched_chunks = Vec::with_capacity(chunks.len());
-        for (chunk_index, at) in chunks {
-            let chunk = self.chunks_data[chunk_index].as_ref().map_or_else(
-                || LoadedData::Missing(at),
-                |chunk_data| match chunk_data.to_chunk(at) {
-                    Ok(chunk) => LoadedData::Loaded(chunk),
-                    Err(err) => LoadedData::Error((at, err)),
-                },
-            );
-
-            fetched_chunks.push(chunk);
-        }
-
-        fetched_chunks
+        chunks
+            .iter()
+            .map(|&at| {
+                let index = AnvilChunkFile::get_chunk_index(&at);
+                let chunk_raw = &self.chunks_data[index];
+
+                match chunk_raw {
+                    Some(chunk_data) => match chunk_data.to_chunk(at) {
+                        Ok(chunk) => LoadedData::Loaded(chunk),
+                        Err(err) => LoadedData::Error((at, err)),
+                    },
+                    None => LoadedData::Missing(at),
+                }
+            })
+            .collect::<Vec<_>>()
     }
 }
 

diff --git a/pumpkin-world/src/chunk/linear.rs b/pumpkin-world/src/chunk/linear.rs
@@ -7,7 +7,6 @@ use bytes::{Buf, BufMut};
 use log::error;
 use pumpkin_config::ADVANCED_CONFIG;
 use pumpkin_util::math::vector2::Vector2;
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 
 use super::anvil::{chunk_to_bytes, CHUNK_COUNT, SUBREGION_BITS};
 use super::{ChunkData, ChunkReadingError, ChunkWritingError};
@@ -304,51 +303,43 @@ impl ChunkSerializer for LinearFile {
     }
 
     fn add_chunks_data(&mut self, chunks_data: &[&Self::Data]) -> Result<(), ChunkWritingError> {
-        let chunks = chunks_data
-            .par_iter()
-            .map(|chunk| (LinearFile::get_chunk_index(&chunk.position), chunk))
-            .collect::<Vec<_>>();
-
-        for (chunk_index, chunk_data) in chunks {
+        for chunk_data in chunks_data {
+            let index = LinearFile::get_chunk_index(&chunk_data.position);
             let chunk_raw = chunk_to_bytes(chunk_data)
                 .map_err(|err| ChunkWritingError::ChunkSerializingError(err.to_string()))?;
 
-            let header = &mut self.chunks_headers[chunk_index];
+            let header = &mut self.chunks_headers[index];
             header.size = chunk_raw.len() as u32;
             header.timestamp = SystemTime::now()
                 .duration_since(UNIX_EPOCH)
                 .unwrap()
                 .as_secs() as u32;
 
             // We update the data buffer
-            self.chunks_data[chunk_index] = Some(chunk_raw);
+            self.chunks_data[index] = Some(chunk_raw);
         }
+
         Ok(())
     }
 
     fn get_chunks_data(
         &self,
         chunks: &[Vector2<i32>],
     ) -> Vec<LoadedData<Self::Data, ChunkReadingError>> {
-        let chunks = chunks
-            .par_iter()
-            .map(|chunk| (LinearFile::get_chunk_index(chunk), *chunk))
-            .collect::<Vec<_>>();
-
-        let mut fetched_chunks = Vec::with_capacity(chunks.len());
-        for (chunk_index, at) in chunks {
-            let chunk = match &self.chunks_data[chunk_index] {
-                None => LoadedData::Missing(at),
-                Some(chunk_bytes) => match ChunkData::from_bytes(chunk_bytes.as_slice(), at) {
-                    Ok(chunk) => LoadedData::Loaded(chunk),
-                    Err(err) => LoadedData::Error((at, ChunkReadingError::ParsingError(err))),
-                },
-            };
-
-            fetched_chunks.push(chunk);
-        }
-
-        fetched_chunks
+        chunks
+            .iter()
+            .map(|&at| {
+                let index = LinearFile::get_chunk_index(&at);
+                let chunk = &self.chunks_data[index];
+                match chunk {
+                    Some(chunk_bytes) => match ChunkData::from_bytes(chunk_bytes, at) {
+                        Ok(chunk) => LoadedData::Loaded(chunk),
+                        Err(err) => LoadedData::Error((at, ChunkReadingError::ParsingError(err))),
+                    },
+                    None => LoadedData::Missing(at),
+                }
+            })
+            .collect::<Vec<_>>()
     }
 }