trees

Author: syntaxerror-9

src/chunk.rs

@@ -3,7 +3,9 @@ use crate::{
         block::{Block, BlockVertexData, FaceDirections},
         block_type::BlockType,
     },
-    world::{NoiseData, CHUNK_SIZE, NOISE_CHUNK_PER_ROW, NOISE_SIZE},
+    structures::Structure,
+    utils::{ChunkFromPosition, RelativeFromAbsolute},
+    world::{NoiseData, CHUNK_SIZE, MAX_TREES_PER_CHUNK, NOISE_CHUNK_PER_ROW, NOISE_SIZE},
 };
 use glam::Vec3;
 use std::sync::{Arc, Mutex};
@@ -23,11 +25,13 @@ pub struct Chunk {
     pub chunk_position_buffer: wgpu::Buffer,
     pub chunk_index_buffer: Option<wgpu::Buffer>,
     pub chunk_vertex_buffer: Option<wgpu::Buffer>,
+    pub outside_blocks: Vec<Arc<Mutex<Block>>>,
 }
 
 impl Chunk {
     pub fn add_block(&mut self, block: Arc<Mutex<Block>>) {
         let block_borrow = block.lock().unwrap();
+
         let y_blocks = self
             .blocks
             .get_mut(
@@ -254,37 +258,39 @@ impl Chunk {
         blocks
     }
     pub fn place_trees(&mut self) {
-        let yblocks = self.blocks.get(&(7 * CHUNK_SIZE as usize) + 7).unwrap();
-        let highest_block = yblocks
-            .last()
-            .as_ref()
-            .unwrap()
-            .as_ref()
-            .unwrap()
-            .lock()
-            .unwrap()
-            .position
-            .clone();
-
-        let base0 = Arc::new(Mutex::new(Block::new(
-            highest_block + glam::vec3(0.0, 1.0, 0.0),
-            (self.x, self.y),
-            BlockType::wood(),
-        )));
-        let base1 = Arc::new(Mutex::new(Block::new(
-            highest_block + glam::vec3(0.0, 2.0, 0.0),
-            (self.x, self.y),
-            BlockType::wood(),
-        )));
-        let base2 = Arc::new(Mutex::new(Block::new(
-            highest_block + glam::vec3(0.0, 3.0, 0.0),
-            (self.x, self.y),
-            BlockType::wood(),
-        )));
-
-        self.add_block(base0);
-        self.add_block(base1);
-        self.add_block(base2);
+        let number_of_trees = rand::random::<f32>();
+        let number_of_trees = f32::floor(number_of_trees * MAX_TREES_PER_CHUNK as f32) as u32;
+
+        for i in 0..number_of_trees {
+            let x = f32::floor(rand::random::<f32>() * CHUNK_SIZE as f32) as usize;
+            let z = f32::floor(rand::random::<f32>() * CHUNK_SIZE as f32) as usize;
+
+            let block_column = self
+                .blocks
+                .get((x * CHUNK_SIZE as usize) + z)
+                .expect("TODO: fix this case");
+            let highest_block = block_column
+                .last()
+                .expect("TODO: Fix this case -h")
+                .as_ref()
+                .unwrap()
+                .lock()
+                .unwrap()
+                .absolute_position;
+
+            let tree_blocks = crate::structures::Tree::get_blocks(highest_block);
+
+            for block in tree_blocks.iter() {
+                let block_brw = block.lock().unwrap();
+                let block_chunk = block_brw.get_chunk_coords();
+                std::mem::drop(block_brw);
+                if block_chunk == (self.x, self.y) {
+                    self.add_block(block.clone());
+                } else {
+                    self.outside_blocks.push(block.clone())
+                }
+            }
+        }
     }
 
     pub fn new(
@@ -325,6 +331,7 @@ impl Chunk {
             chunk_bind_group,
             chunk_position_buffer,
             indices: 0,
+            outside_blocks: vec![],
         };
         chunk.place_trees();
         chunk.build_mesh(other_chunks);

src/main.rs

@@ -37,6 +37,7 @@ pub mod material;
 pub mod pipeline;
 pub mod player;
 pub mod state;
+pub mod structures;
 pub mod ui;
 pub mod utils;
 pub mod world;

src/structures/mod.rs

@@ -0,0 +1,11 @@
+pub mod tree;
+
+use std::sync::{Arc, Mutex};
+
+pub trait Structure {
+    // position: Initial absolute position
+    fn get_blocks(position: glam::Vec3) -> Vec<Arc<Mutex<Block>>>;
+}
+pub use tree::Tree;
+
+use crate::blocks::block::Block; // Reexport into structures module

src/structures/tree.rs

@@ -0,0 +1,61 @@
+use std::sync::{Arc, Mutex};
+
+use crate::{
+    blocks::{block::Block, block_type::BlockType},
+    utils::{ChunkFromPosition, RelativeFromAbsolute},
+};
+
+use super::Structure;
+
+pub struct Tree;
+
+impl Structure for Tree {
+    fn get_blocks(position: glam::Vec3) -> Vec<Arc<Mutex<Block>>> {
+        let trunk_pos = [
+            position + glam::vec3(0.0, 1.0, 0.0),
+            position + glam::vec3(0.0, 2.0, 0.0),
+            position + glam::vec3(0.0, 3.0, 0.0),
+        ];
+
+        #[rustfmt::skip]
+        let leafs_pos = [
+            position + glam::vec3(0.0, 3.0, 1.0),
+            position + glam::vec3(0.0, 4.0, 1.0),
+            position + glam::vec3(1.0, 3.0, 1.0),
+            position + glam::vec3(1.0, 4.0, 1.0),
+            position + glam::vec3(-1.0, 3.0, 1.0),
+            position + glam::vec3(-1.0, 4.0, 1.0),
+
+            position + glam::vec3(0.0, 3.0, -1.0),
+            position + glam::vec3(0.0, 4.0, -1.0),
+            position + glam::vec3(1.0, 3.0, -1.0),
+            position + glam::vec3(1.0, 4.0, -1.0),
+            position + glam::vec3(-1.0, 3.0, -1.0),
+            position + glam::vec3(-1.0, 4.0, -1.0),
+
+            position + glam::vec3(1.0, 3.0, 0.0),
+            position + glam::vec3(1.0, 4.0, 0.0),
+            position + glam::vec3(-1.0, 3.0, 0.0),
+            position + glam::vec3(-1.0, 4.0, 0.0),
+
+            position + glam::vec3(0.0, 5.0, 0.0),
+        ];
+
+        let blocks = trunk_pos.iter().map(|p| {
+            Arc::new(Mutex::new(Block::new(
+                p.relative_from_absolute(),
+                p.get_chunk_from_position_absolute(),
+                BlockType::wood(),
+            )))
+        });
+        let leafs_iter = leafs_pos.iter().map(|p| {
+            Arc::new(Mutex::new(Block::new(
+                p.relative_from_absolute(),
+                p.get_chunk_from_position_absolute(),
+                BlockType::leaf(),
+            )))
+        });
+        let blocks = blocks.chain(leafs_iter).collect::<Vec<_>>();
+        return blocks;
+    }
+}

src/world.rs

@@ -12,6 +12,7 @@ pub const CHUNK_HEIGHT: u8 = u8::MAX;
 pub const NOISE_SIZE: u32 = 1024;
 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;
 // There will be a CHUNKS_PER_ROW * CHUNKS_PER_ROW region
 pub const CHUNKS_PER_ROW: u32 = 9;