Basic world gen

Author: ReCore-sys

Cargo.toml

@@ -33,7 +33,7 @@ members = [
     "src/lib/utils/general_purpose",
     "src/lib/utils/logging",
     "src/lib/utils/profiling",
-    "src/lib/world",
+    "src/lib/world", "src/lib/world_gen",
 ]
 
 #================== Lints ==================#
@@ -81,7 +81,7 @@ ferrumc-anvil = { path = "src/lib/adapters/anvil" }
 ferrumc-config = { path = "src/lib/utils/config" }
 ferrumc-core = { path = "src/lib/core" }
 ferrumc-ecs = { path = "src/lib/ecs" }
-ferrumc-events = { path = "src/lib/events"}
+ferrumc-events = { path = "src/lib/events" }
 ferrumc-general-purpose = { path = "src/lib/utils/general_purpose" }
 ferrumc-logging = { path = "src/lib/utils/logging" }
 ferrumc-macros = { path = "src/lib/derive_macros" }
@@ -96,6 +96,7 @@ ferrumc-storage = { path = "src/lib/storage" }
 ferrumc-text = { path = "src/lib/text" }
 ferrumc-utils = { path = "src/lib/utils" }
 ferrumc-world = { path = "src/lib/world" }
+ferrumc-world-gen = { path = "src/lib/world_gen" }
 
 
 
@@ -156,7 +157,7 @@ maplit = "1.0.2"
 macro_rules_attribute = "0.2.0"
 
 # Magic ("life-before-main" initialization, __attribute__((constructor)))
-ctor = "0.2.9"
+ctor = "0.4.0"
 
 # Compression/Decompression
 libflate = "2.1.0"
@@ -174,12 +175,13 @@ moka = "0.12.8"
 # CLI
 clap = "4.5.20"
 indicatif = "0.17.8"
-colored = "2.1.0"
+colored = "3.0.0"
 
 # Misc
 deepsize = "0.2.0"
 page_size = "0.6.0"
 regex = "1.11.1"
+noise = "0.9.0"
 
 # I/O
 memmap2 = "0.9.5"

src/bin/Cargo.toml

@@ -26,8 +26,9 @@ ferrumc-macros = { workspace = true }
 ferrumc-nbt = { workspace = true }
 ferrumc-general-purpose = { workspace = true }
 ferrumc-state = { workspace = true }
+ferrumc-world-gen = { workspace = true }
 
-parking_lot = { workspace = true, features = ["deadlock_detection"] }
+rayon = { workspace = true }
 tracing = { workspace = true }
 tokio = { workspace = true }
 futures = { workspace = true }
@@ -36,6 +37,7 @@ clap = { workspace = true, features = ["derive"] }
 flate2 = { workspace = true }
 ctor = { workspace = true }
 rand = { workspace = true }
+log = "0.4.22"
 
 
 [[bin]]

src/bin/src/main.rs

@@ -1,5 +1,4 @@
 #![feature(portable_simd)]
-#![forbid(unsafe_code)]
 #![feature(random)]
 extern crate core;
 
@@ -11,7 +10,11 @@ use ferrumc_ecs::Universe;
 use ferrumc_general_purpose::paths::get_root_path;
 use ferrumc_net::server::create_server_listener;
 use ferrumc_state::ServerState;
+use ferrumc_world::chunk_format::Chunk;
 use ferrumc_world::World;
+use ferrumc_world_gen::errors::WorldGenError;
+use ferrumc_world_gen::WorldGenerator;
+use rayon::prelude::*;
 use std::sync::Arc;
 use systems::definition;
 use tokio::runtime::Handle;
@@ -23,8 +26,6 @@ mod cli;
 mod packet_handlers;
 mod systems;
 
-pub type Result<T> = std::result::Result<T, BinaryError>;
-
 // #[tokio::main(flavor = "current_thread")]
 #[tokio::main(flavor = "multi_thread")]
 async fn main() {
@@ -64,10 +65,41 @@ async fn main() {
     }
 }
 
-async fn entry() -> Result<()> {
+async fn entry() -> Result<(), BinaryError> {
     let state = create_state().await?;
     let global_state = Arc::new(state);
     create_whitelist().await;
+    if !global_state.world.chunk_exists(0, 0, "overworld").await? {
+        info!("No overworld spawn chunk found, generating spawn chunks...");
+        // Generate a 12x12 chunk area around the spawn point
+        let mut chunks = Vec::new();
+        for x in -12..12 {
+            for z in -12..12 {
+                chunks.push((x, z));
+            }
+        }
+        let generated_chunks: Vec<Result<Chunk, WorldGenError>> = chunks
+            .chunks(72)
+            .par_bridge()
+            .map(|chunk_coord_arr| {
+                let mut generated_chunks = Vec::new();
+                for (x, z) in chunk_coord_arr {
+                    let state = global_state.clone();
+                    generated_chunks.push(state.terrain_generator.generate_chunk(*x, *z));
+                }
+                generated_chunks
+            })
+            .flatten()
+            .collect();
+        for chunk in generated_chunks {
+            let chunk = chunk.map_err(|e| {
+                error!("Error generating chunk: {:?}", e);
+                BinaryError::Custom("Error generating chunk".to_string())
+            })?;
+            global_state.world.save_chunk(chunk).await?;
+        }
+        info!("Finished generating spawn chunks...");
+    }
 
     let all_system_handles = tokio::spawn(definition::start_all_systems(global_state.clone()));
 
@@ -80,7 +112,7 @@ async fn entry() -> Result<()> {
     Ok(())
 }
 
-async fn handle_import(import_args: ImportArgs) -> Result<()> {
+async fn handle_import(import_args: ImportArgs) -> Result<(), BinaryError> {
     //! Handles the import of the world.
     info!("Importing world...");
 
@@ -107,12 +139,13 @@ async fn handle_import(import_args: ImportArgs) -> Result<()> {
     Ok(())
 }
 
-async fn create_state() -> Result<ServerState> {
+async fn create_state() -> Result<ServerState, BinaryError> {
     let listener = create_server_listener().await?;
 
     Ok(ServerState {
         universe: Universe::new(),
         tcp_listener: listener,
         world: World::new().await,
+        terrain_generator: WorldGenerator::new(0),
     })
 }

src/bin/src/systems/tcp_listener_system.rs

@@ -1,5 +1,5 @@
+use crate::errors::BinaryError;
 use crate::systems::definition::System;
-use crate::Result;
 use async_trait::async_trait;
 use ferrumc_net::connection::handle_connection;
 use ferrumc_state::GlobalState;
@@ -26,7 +26,7 @@ impl System for TcpListenerSystem {
 }
 
 impl TcpListenerSystem {
-    async fn initiate_loop(state: GlobalState) -> Result<()> {
+    async fn initiate_loop(state: GlobalState) -> Result<(), BinaryError> {
         let tcp_listener = &state.tcp_listener;
         info!("Server is listening on [{}]", tcp_listener.local_addr()?);
 

src/lib/core/state/Cargo.toml

@@ -7,3 +7,4 @@ edition = "2021"
 tokio = { workspace = true }
 ferrumc-ecs = { workspace = true }
 ferrumc-world = { workspace = true }
+ferrumc-world-gen = { workspace = true }

src/lib/core/state/src/lib.rs

@@ -1,11 +1,14 @@
 use ferrumc_ecs::Universe;
 use ferrumc_world::World;
+use ferrumc_world_gen::WorldGenerator;
 use std::sync::Arc;
 use tokio::net::TcpListener;
+
 pub struct ServerState {
     pub universe: Universe,
     pub tcp_listener: TcpListener,
     pub world: World,
+    pub terrain_generator: WorldGenerator,
 }
 
 pub type GlobalState = Arc<ServerState>;

src/lib/world/src/chunk_format.rs

@@ -12,7 +12,7 @@ use std::cmp::max;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::io::Read;
-use tracing::{debug, error, warn};
+use tracing::{error, warn};
 use vanilla_chunk_format::BlockData;
 
 #[cfg(test)]
@@ -384,7 +384,7 @@ impl Chunk {
         // Get old block
         let old_block = self.get_block(x, y, z)?;
         if old_block == block {
-            debug!("Block is the same as the old block");
+            // debug!("Block is the same as the old block");
             return Ok(());
         }
         // Get section
@@ -533,7 +533,6 @@ impl Chunk {
             .ok_or(WorldError::SectionOutOfBounds(y >> 4))?;
         match &section.block_states.block_data {
             PaletteType::Single(val) => {
-                debug!(x, y, z, "Single palette type");
                 let block_id = val.val;
                 ID2BLOCK
                     .get(&block_id)
@@ -616,11 +615,15 @@ impl Chunk {
     ///
     /// * `Ok(())` - If the section was successfully set.
     /// * `Err(WorldError)` - If an error occurs while setting the section.
-    pub fn set_section(&mut self, section: u8, block: BlockData) -> Result<(), WorldError> {
-        if let Some(section) = self.sections.get_mut(section as usize) {
+    pub fn set_section(&mut self, section_y: i8, block: BlockData) -> Result<(), WorldError> {
+        if let Some(section) = self
+            .sections
+            .iter_mut()
+            .find(|section| section.y == section_y)
+        {
             section.fill(block.clone())
         } else {
-            Err(WorldError::SectionOutOfBounds(section as i32))
+            Err(WorldError::SectionOutOfBounds(section_y as i32))
         }
     }
 

src/lib/world_gen/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "ferrumc-world-gen"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+ferrumc-world = { workspace = true }
+thiserror = { workspace = true }
+noise = { workspace = true }
+
+[lints]
+workspace = true

src/lib/world_gen/src/biomes/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod plains;

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

@@ -0,0 +1,95 @@
+use crate::errors::WorldGenError;
+use crate::{BiomeGenerator, NoiseGenerator};
+use ferrumc_world::chunk_format::Chunk;
+use ferrumc_world::vanilla_chunk_format::BlockData;
+use std::collections::BTreeMap;
+
+pub(crate) struct PlainsBiome;
+
+impl BiomeGenerator for PlainsBiome {
+    fn _biome_id(&self) -> u8 {
+        0
+    }
+
+    fn _biome_name(&self) -> String {
+        "plains".to_string()
+    }
+
+    fn generate_chunk(
+        &self,
+        x: i32,
+        z: i32,
+        noise: &NoiseGenerator,
+    ) -> Result<Chunk, WorldGenError> {
+        let mut chunk = Chunk::new(x, z, "overworld".to_string());
+        let mut heights = vec![];
+        let stone = BlockData {
+            name: "minecraft:stone".to_string(),
+            properties: None,
+        };
+
+        // Fill with water first
+        for section_y in -4..4 {
+            chunk.set_section(
+                section_y as i8,
+                BlockData {
+                    name: "minecraft:water".to_string(),
+                    properties: Some(BTreeMap::from([("level".to_string(), "0".to_string())])),
+                },
+            )?;
+        }
+
+        // Then generate some heights
+        for chunk_x in 0..16 {
+            for chunk_z in 0..16 {
+                let global_x = x * 16 + chunk_x;
+                let global_z = z * 16 + chunk_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));
+            }
+        }
+
+        // Fill in the sections that consist of only stone first with the set_section method since
+        // it's faster than set_block
+        let y_min = heights.iter().min_by(|a, b| a.2.cmp(&b.2)).unwrap().2;
+        let heighst_full_section = y_min / 16;
+        for section_y in -4..heighst_full_section {
+            chunk.set_section(section_y as i8, stone.clone())?;
+        }
+        let above_filled_sections = (heighst_full_section * 16) - 1;
+        for (global_x, global_z, height) in heights {
+            if height > above_filled_sections {
+                let height = height - above_filled_sections;
+                for y in 0..height {
+                    if y + above_filled_sections <= 64 {
+                        chunk.set_block(
+                            global_x & 0xF,
+                            y + above_filled_sections,
+                            global_z & 0xF,
+                            BlockData {
+                                name: "minecraft:sand".to_string(),
+                                properties: None,
+                            },
+                        )?;
+                    } else {
+                        chunk.set_block(
+                            global_x & 0xF,
+                            y + above_filled_sections,
+                            global_z & 0xF,
+                            BlockData {
+                                name: "minecraft:grass_block".to_string(),
+                                properties: Some(BTreeMap::from([(
+                                    "snowy".to_string(),
+                                    "false".to_string(),
+                                )])),
+                            },
+                        )?;
+                    }
+                }
+            }
+        }
+
+        Ok(chunk)
+    }
+}