cleanup and use of built in methods

Author: syntaxerror-9

src/chunk.rs

@@ -43,7 +43,7 @@ pub struct Chunk {
     pub chunk_water_index_buffer: Option<wgpu::Buffer>,
     pub outside_blocks: Vec<Arc<RwLock<Block>>>,
     pub visible: bool,
-    pub modified: bool, // if it should be saved
+    pub modified: bool, // if true, it will be saved
 }
 
 impl Chunk {
@@ -57,13 +57,8 @@ impl Chunk {
             .get_mut(((block_position.x * CHUNK_SIZE as f32) + block_position.z) as usize)
             .expect("Cannot add oob block");
 
-        let start_len = y_blocks.len();
-
-        /* Make sure we don't have enough space in the vector */
-        for i in start_len..=block_position.y as usize {
-            if i >= y_blocks.len() {
-                y_blocks.push(None);
-            }
+        if block_position.y as usize >= y_blocks.len() {
+            y_blocks.resize(block_position.y as usize + 1, None);
         }
 
         y_blocks[block_position.y as usize] = Some(block);
@@ -215,16 +210,15 @@ impl Chunk {
                                     }
                                 }
                                 None => {
-                                    if face_position.y as u32
-                                        <= Chunk::get_height_value(
-                                            target_chunk_x,
-                                            target_chunk_y,
-                                            target_block.x as u32,
-                                            target_block.z as u32,
-                                            self.noise_data.clone(),
-                                        )
-                                        && face_position.y >= WATER_HEIGHT_LEVEL as f32
-                                    {
+                                    let h = Chunk::get_height_value(
+                                        target_chunk_x,
+                                        target_chunk_y,
+                                        target_block.x as u32,
+                                        target_block.z as u32,
+                                        self.noise_data.clone(),
+                                    );
+
+                                    if face_position.y as u32 <= h {
                                         is_visible = false
                                     };
                                 }

src/world.rs

@@ -24,7 +24,7 @@ pub const FREQUENCY: f32 = 1. / 128.;
 pub const NOISE_CHUNK_PER_ROW: u32 = NOISE_SIZE / CHUNK_SIZE;
 pub const MAX_TREES_PER_CHUNK: u32 = 3;
 
-pub const CHUNKS_PER_ROW: u32 = 60;
+pub const CHUNKS_PER_ROW: u32 = 9;
 pub const CHUNKS_REGION: u32 = CHUNKS_PER_ROW * CHUNKS_PER_ROW;
 pub const WATER_HEIGHT_LEVEL: u8 = 5;
 
@@ -56,61 +56,39 @@ pub struct World {
 }
 
 impl World {
-    // pub fn get_other_chunks(&self, chunk_ptr: WorldChunk) -> Vec<WorldChunk> {
-    //     self.chunks
-    //         .values()
-    //         .filter_map(|c| {
-    //             return if !Arc::ptr_eq(&chunk_ptr, c) {
-    //                 Some(c.clone())
-    //             } else {
-    //                 None
-    //             };
-    //         })
-    //         .collect()
-    // }
     pub fn place_block(&mut self, block: Arc<RwLock<Block>>) {
         let block_borrow = block.read().unwrap();
         let mut chunks_to_rerender = vec![block_borrow.get_chunk_coords()];
+        chunks_to_rerender.append(&mut block_borrow.get_neighbour_chunks_coords());
+
         let chunk_map = self.chunks.read().unwrap();
         let chunk = chunk_map
             .get(&chunks_to_rerender[0])
             .expect("Cannot delete a block from unloaded chunk");
 
-        let mut chunk_lock = chunk.write().unwrap();
-        chunk_lock.add_block(block.clone(), true);
-
-        let block_borrow = block.read().unwrap();
-        chunks_to_rerender.append(&mut block_borrow.get_neighbour_chunks_coords());
-        std::mem::drop(chunk_lock);
-
-        // if block_neighbour_chunks.len() > 0 {
-        //     for neighbour_chunk in block_neighbour_chunks {
-        //         let neighbour_chunk = self
-        //             .chunks
-        //             .get(&neighbour_chunk)
-        //             .expect("Cannot destroy a block without neighbour being loaded");
-
-        //         chunks_to_rerender.push(neighbour_chunk.clone());
-        //     }
-        // }
+        {
+            let mut chunk_lock = chunk.write().unwrap();
+            chunk_lock.add_block(block.clone(), true);
+            // Drop chunk lock write
+        }
 
         self.render_chunks(chunks_to_rerender)
-        // self.render_chunks(block_neighbour_chunks.append(&mut vec![chunk_coords]));
     }
     pub fn remove_block(&mut self, block: Arc<RwLock<Block>>) {
         let block_borrow = block.read().unwrap();
         let mut chunks_to_rerender = vec![block_borrow.get_chunk_coords()];
+        chunks_to_rerender.append(&mut block_borrow.get_neighbour_chunks_coords());
+
         let chunk_map = self.chunks.read().unwrap();
         let chunk = chunk_map
             .get(&chunks_to_rerender[0])
             .expect("Cannot delete a block from unloaded chunk");
 
-        let mut chunk_lock = chunk.write().unwrap();
-        chunk_lock.remove_block(&(block_borrow.position));
-        // chunk_lock.build_mesh(self.get_other_chunks(chunk.clone()));
-        chunks_to_rerender.append(&mut block_borrow.get_neighbour_chunks_coords());
-        // I hate this so much
-        std::mem::drop(chunk_lock);
+        {
+            let mut chunk_lock = chunk.write().unwrap();
+            chunk_lock.remove_block(&(block_borrow.position));
+            // Drop chunk lock write
+        }
 
         self.render_chunks(chunks_to_rerender);
     }
@@ -144,9 +122,6 @@ impl World {
 
         for position in positions.iter() {
             if let Some(block) = self.get_blocks_absolute(position) {
-                if block.read().unwrap().block_type == BlockType::Water {
-                    continue;
-                }
                 nearby_blocks.push(block)
             };
         }