feat: sand

Author: syntaxerror-9

assets/tex_atlas.png

@@ -1,6 +1,8 @@
-use rand::random;
+use rand::{random, rngs::StdRng, Rng, SeedableRng};
 use std::any::Any;
 
+use crate::world::{RNG_SEED, WATER_HEIGHT_LEVEL};
+
 use super::block::{FaceDirections, TexturedBlock};
 
 #[derive(Clone, Copy, Debug)]
@@ -49,6 +51,11 @@ impl BlockTypeConfigs {
                 textures: [FaceTexture(3), FaceTexture(3), FaceTexture(3)],
                 is_translucent: false,
             },
+            BlockType::Sand => BlockTypeConfigs {
+                id: 6,
+                textures: [FaceTexture(9), FaceTexture(9), FaceTexture(9)],
+                is_translucent: false,
+            },
         }
     }
 }
@@ -62,6 +69,7 @@ pub enum BlockType {
     Wood,
     Leaf,
     Stone,
+    Sand,
 }
 impl BlockType {
     pub fn get_config(&self) -> BlockTypeConfigs {
@@ -78,28 +86,44 @@ impl BlockType {
             3 => Self::Wood,
             4 => Self::Leaf,
             5 => Self::Stone,
+            6 => Self::Sand,
             _ => panic!("Invalid id"),
         }
     }
 }
+fn calc_scalar(y: u32, t: Threshold) -> f32 {
+    (y as f32 - t[0] as f32) / (t[1] as f32 - t[0] as f32)
+}
+// Threshold: ( lowerbound , upperbound )
+type Threshold = [u32; 2];
+const STONE_THRESHOLD: Threshold = [15, 24];
+const SAND_THRESHOLD: Threshold = [WATER_HEIGHT_LEVEL as u32, WATER_HEIGHT_LEVEL as u32 + 2];
 impl BlockType {
-    const U_STONE_THRESHOLD: u32 = 20;
-    const L_STONE_THRESHOLD: u32 = 1;
+    pub fn from_position(x: u32, y: u32, z: u32) -> BlockType {
+        let mut rng = StdRng::seed_from_u64(RNG_SEED + (y * x * z) as u64);
 
-    pub fn from_y_position(y: u32) -> BlockType {
-        if y > Self::U_STONE_THRESHOLD {
-            let t: f32 = random();
-            let scaler = (y as f32 - Self::U_STONE_THRESHOLD as f32) / 10.0;
-            let res = t + scaler;
-            if res > 1.0 {
+        if y <= SAND_THRESHOLD[0] {
+            BlockType::Sand
+        } else if y <= SAND_THRESHOLD[1] {
+            let r = rng.gen::<f32>();
+            let s = calc_scalar(y, SAND_THRESHOLD);
+            if r + s > 1.0 {
+                BlockType::Dirt
+            } else {
+                BlockType::Sand
+            }
+        } else if y < STONE_THRESHOLD[0] {
+            BlockType::Dirt
+        } else if y <= STONE_THRESHOLD[1] {
+            let r = rng.gen::<f32>();
+            let s = calc_scalar(y, STONE_THRESHOLD);
+            if r + s >= 1.0 {
                 BlockType::Stone
             } else {
                 BlockType::Dirt
             }
-        } else if y < Self::L_STONE_THRESHOLD {
-            BlockType::Stone
         } else {
-            BlockType::Dirt
+            BlockType::Stone
         }
     }
 }

src/blocks/block_type.rs

@@ -2,7 +2,7 @@ use crate::blocks::block_type::BlockType::Water;
 use crate::persistence::{Loadable, Saveable};
 use crate::player::Player;
 use crate::utils::math_utils::Plane;
-use crate::world::{WorldChunk, WATER_HEIGHT_LEVEL};
+use crate::world::{WorldChunk, RNG_SEED, WATER_HEIGHT_LEVEL};
 use crate::{
     blocks::{
         block::{Block, BlockVertexData, FaceDirections},
@@ -360,7 +360,7 @@ impl Chunk {
                 let curr = &mut blocks.write().unwrap()[((x * CHUNK_SIZE) + z) as usize];
 
                 for y in 0..=y_top {
-                    let block_type = match BlockType::from_y_position(y) {
+                    let block_type = match BlockType::from_position(x, y, z) {
                         BlockType::Dirt if y == y_top => BlockType::Grass,
                         b => b,
                     };
@@ -391,7 +391,7 @@ impl Chunk {
     }
     // TODO: Use white noise + check that the tree is not being placed on water.
     pub fn place_trees(&mut self) {
-        let mut rng = StdRng::seed_from_u64((self.x * 10 * self.y) as u64);
+        let mut rng = StdRng::seed_from_u64((self.x * 10 * self.y) as u64 + RNG_SEED);
         let number_of_trees = rng.gen::<f32>();
         let mut number_of_trees = f32::floor(number_of_trees * MAX_TREES_PER_CHUNK as f32) as u32;
 

src/chunk.rs

@@ -23,6 +23,8 @@ pub(crate) mod math_utils {
 pub(crate) mod noise {
     use std::fmt::Debug;
 
+    use crate::world::RNG_SEED;
+
     use super::*;
     use glam::Vec2;
 
@@ -41,7 +43,7 @@ pub(crate) mod noise {
     pub fn shuffle<T: Copy + Debug>(vec: &mut Vec<T>) -> &mut Vec<T> {
         use rand::prelude::*;
 
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(RNG_SEED);
 
         for i in (0..vec.len()).rev() {
             let a: usize = if i > 0 {

src/utils.rs

@@ -14,14 +14,15 @@ use crate::persistence::Saveable;
 use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
 use crate::{blocks::block::Block, chunk::Chunk, player::Player, utils::threadpool::ThreadPool};
 
+pub const RNG_SEED: u64 = 0;
 pub const CHUNK_SIZE: u32 = 16;
 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;
 
-pub const CHUNKS_PER_ROW: u32 = 25;
+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;