make chunk gen use ChunkPos

Author: Mcrtin

src/bin/src/launch.rs

@@ -47,7 +47,7 @@ pub fn generate_spawn_chunks(state: GlobalState) -> Result<(), BinaryError> {
         batch.execute(move || {
             let chunk = state_clone
                 .terrain_generator
-                .generate_chunk(x, z)
+                .generate_chunk(ChunkPos::new(x, z))
                 .map(Arc::new);
 
             match chunk {

src/bin/src/packet_handlers/play_packets/player_action.rs

@@ -53,10 +53,7 @@ pub fn handle(
                                 .0
                                 .clone()
                                 .terrain_generator
-                                .generate_chunk(
-                                    event.location.x.div_euclid(16),
-                                    event.location.z.div_euclid(16),
-                                )
+                                .generate_chunk(BlockPos::from(event.location.clone()).chunk())
                                 .map_err(BinaryError::WorldGen)?
                         }
                     };

src/bin/src/systems/chunk_sending.rs

@@ -82,7 +82,7 @@ pub fn handle(
                             state
                                 .0
                                 .terrain_generator
-                                .generate_chunk(coordinates.x(), coordinates.z())
+                                .generate_chunk(coordinates)
                                 .expect("Could not generate chunk")
                                 .into(),
                         );

src/bin/src/systems/listeners/digging_system.rs

@@ -285,7 +285,7 @@ fn break_block(
                 .0
                 .clone()
                 .terrain_generator
-                .generate_chunk(position.x >> 4, position.z >> 4)
+                .generate_chunk(BlockPos::from(position.clone()).chunk())
                 .map_err(BinaryError::WorldGen)?
         }
     };

src/lib/net/benches/packets.rs

@@ -9,7 +9,7 @@ pub fn bench_packets(c: &mut criterion::BenchmarkGroup<WallTime>) {
 
 fn bench_chunk_packet(c: &mut criterion::BenchmarkGroup<WallTime>) {
     let chunk = ferrumc_world_gen::WorldGenerator::new(0)
-        .generate_chunk(0, 0)
+        .generate_chunk(ChunkPos::new(0, 0))
         .unwrap();
     let chunk_packet = black_box(
         ferrumc_net::packets::outgoing::chunk_and_light_data::ChunkAndLightData::from_chunk(

src/lib/net/src/conn_init/login.rs

@@ -472,7 +472,7 @@ fn send_initial_chunks(
                     let chunk = state.world.load_chunk(ChunkPos::new(x,z), "overworld").unwrap_or(
                         state
                             .terrain_generator
-                            .generate_chunk(x, z)
+                            .generate_chunk(ChunkPos::new(x, z))
                             .expect("Could not generate chunk")
                             .into(),
                     );

src/lib/world/src/pos.rs

@@ -108,11 +108,13 @@ impl ChunkHeight {
 
 #[derive(Hash, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ChunkPos {
-    pos: IVec2,
+    pub pos: IVec2,
 }
 
 impl ChunkPos {
-    pub fn new(x: i32, z: i32) -> Self {
+    pub const fn new(x: i32, z: i32) -> Self {
+        assert!(x < 1 << 22);
+        assert!(z < 1 << 22);
         Self {
             pos: IVec2::new(x * 16, z * 16),
         }
@@ -259,6 +261,14 @@ impl ColumnPos {
     pub fn chunk(self) -> ChunkPos {
         ChunkPos::new(self.pos.x, self.pos.y)
     }
+
+    pub fn x(&self) -> i32 {
+        self.pos.x
+    }
+
+    pub fn z(&self) -> i32 {
+        self.pos.y
+    }
 }
 
 impl From<IVec2> for ColumnPos {

src/lib/world_gen/src/biomes/plains.rs

@@ -4,7 +4,7 @@ use ferrumc_macros::block;
 use ferrumc_world::block_state_id::BlockStateId;
 use ferrumc_world::chunk_format::Chunk;
 use ferrumc_world::edit_batch::EditBatch;
-use ferrumc_world::pos::{BlockPos, ChunkHeight};
+use ferrumc_world::pos::{BlockPos, ChunkColumnPos, ChunkHeight, ChunkPos};
 
 pub(crate) struct PlainsBiome;
 
@@ -19,8 +19,7 @@ impl BiomeGenerator for PlainsBiome {
 
     fn generate_chunk(
         &self,
-        x: i32,
-        z: i32,
+        pos: ChunkPos,
         noise: &NoiseGenerator,
     ) -> Result<Chunk, WorldGenError> {
         let mut chunk = Chunk::new(ChunkHeight::new(-64, 384));
@@ -33,11 +32,12 @@ impl BiomeGenerator for PlainsBiome {
         }
 
         // Then generate some heights
-        for chunk_x in 0..16i64 {
-            for chunk_z in 0..16i64 {
-                let global_x = i64::from(x) * 16 + chunk_x;
-                let global_z = i64::from(z) * 16 + chunk_z;
-                let height = noise.get_noise(global_x as f64, global_z as f64);
+        for chunk_x in 0..16 {
+            for chunk_z in 0..16 {
+                let curr_pos = pos.column_pos(ChunkColumnPos::new(chunk_x, chunk_z));
+                let global_x = curr_pos.x();
+                let global_z = curr_pos.z();
+                let height = noise.get_noise(f64::from(global_x), f64::from(global_z));
                 let height = (height * 64.0) as i32 + 64;
                 heights.push((global_x, global_z, height));
             }
@@ -58,22 +58,14 @@ impl BiomeGenerator for PlainsBiome {
                 for y in 0..height {
                     if y + above_filled_sections <= 64 {
                         batch.set_block(
-                            BlockPos::of(
-                                global_x as i32,
-                                y + above_filled_sections,
-                                global_z as i32,
-                            )
-                            .chunk_block_pos(),
+                            BlockPos::of(global_x, y + above_filled_sections, global_z)
+                                .chunk_block_pos(),
                             block!("sand"),
                         );
                     } else {
                         batch.set_block(
-                            BlockPos::of(
-                                global_x as i32,
-                                y + above_filled_sections,
-                                global_z as i32,
-                            )
-                            .chunk_block_pos(),
+                            BlockPos::of(global_x, y + above_filled_sections, global_z)
+                                .chunk_block_pos(),
                             block!("grass_block", {snowy: false}),
                         );
                     }
@@ -95,17 +87,25 @@ mod test {
     fn test_is_ok() {
         let generator = PlainsBiome {};
         let noise = NoiseGenerator::new(0);
-        assert!(generator.generate_chunk(0, 0, &noise).is_ok());
+        assert!(
+            generator
+                .generate_chunk(ChunkPos::new(0, 0), &noise)
+                .is_ok()
+        );
     }
 
     #[test]
     fn test_random_chunk_generation() {
         let generator = PlainsBiome {};
         let noise = NoiseGenerator::new(0);
         for _ in 0..100 {
-            let x = rand::random::<i32>();
-            let z = rand::random::<i32>();
-            assert!(generator.generate_chunk(x, z, &noise).is_ok());
+            let x = rand::random::<i32>() & ((1 << 22) - 1);
+            let z = rand::random::<i32>() & ((1 << 22) - 1);
+            assert!(
+                generator
+                    .generate_chunk(ChunkPos::new(x, z), &noise)
+                    .is_ok()
+            );
         }
     }
 
@@ -115,12 +115,12 @@ mod test {
         let noise = NoiseGenerator::new(0);
         assert!(
             generator
-                .generate_chunk(1610612735, 1610612735, &noise)
+                .generate_chunk(ChunkPos::new((1 << 22) - 1, (1 << 22) - 1), &noise)
                 .is_ok()
         );
         assert!(
             generator
-                .generate_chunk(-1610612735, -1610612735, &noise)
+                .generate_chunk(ChunkPos::new(-((1 << 22) - 1), -((1 << 22) - 1)), &noise)
                 .is_ok()
         );
     }
@@ -131,7 +131,11 @@ mod test {
             let generator = PlainsBiome {};
             let seed = rand::random::<u64>();
             let noise = NoiseGenerator::new(seed);
-            assert!(generator.generate_chunk(0, 0, &noise).is_ok());
+            assert!(
+                generator
+                    .generate_chunk(ChunkPos::new(0, 0), &noise)
+                    .is_ok()
+            );
         }
     }
 }

src/lib/world_gen/src/lib.rs

@@ -2,7 +2,7 @@ mod biomes;
 pub mod errors;
 
 use crate::errors::WorldGenError;
-use ferrumc_world::chunk_format::Chunk;
+use ferrumc_world::{chunk_format::Chunk, pos::ChunkPos};
 use noise::{Clamp, NoiseFn, OpenSimplex};
 
 /// Trait for generating a biome
@@ -11,12 +11,8 @@ use noise::{Clamp, NoiseFn, OpenSimplex};
 pub(crate) trait BiomeGenerator {
     fn _biome_id(&self) -> u8;
     fn _biome_name(&self) -> String;
-    fn generate_chunk(
-        &self,
-        x: i32,
-        z: i32,
-        noise: &NoiseGenerator,
-    ) -> Result<Chunk, WorldGenError>;
+    fn generate_chunk(&self, pos: ChunkPos, noise: &NoiseGenerator)
+    -> Result<Chunk, WorldGenError>;
 }
 
 pub(crate) struct NoiseGenerator {
@@ -57,13 +53,13 @@ impl WorldGenerator {
         }
     }
 
-    fn get_biome(&self, _x: i32, _z: i32) -> Box<dyn BiomeGenerator> {
+    fn get_biome(&self, _pos: ChunkPos) -> Box<dyn BiomeGenerator> {
         // Implement biome selection here
         Box::new(biomes::plains::PlainsBiome)
     }
 
-    pub fn generate_chunk(&self, x: i32, z: i32) -> Result<Chunk, WorldGenError> {
-        let biome = self.get_biome(x, z);
-        biome.generate_chunk(x, z, &self.noise_generator)
+    pub fn generate_chunk(&self, pos: ChunkPos) -> Result<Chunk, WorldGenError> {
+        let biome = self.get_biome(pos);
+        biome.generate_chunk(pos, &self.noise_generator)
     }
 }