Merge pull request #179 from ferrumc-rs/feature/optimised-chunks

Author: ReCore-sys

.etc/raw_chunk.dat

@@ -189,6 +189,7 @@ page_size = "0.6.0"
 regex = "1.11.1"
 noise = "0.9.0"
 ctrlc = "3.4.7"
+num_cpus = "1.16.0"
 typename = "0.1.2"
 bevy_ecs = { version = "0.16.0", features = ["multi_threaded", "trace"] }
 

Cargo.toml

@@ -6,11 +6,11 @@ use ferrumc_config::statics::get_global_config;
 use ferrumc_config::whitelist::create_whitelist;
 use ferrumc_general_purpose::paths::get_root_path;
 use ferrumc_state::{GlobalState, ServerState};
-use ferrumc_world::chunk_format::Chunk;
+use ferrumc_threadpool::ThreadPool;
 use ferrumc_world::World;
-use ferrumc_world_gen::errors::WorldGenError;
 use ferrumc_world_gen::WorldGenerator;
 use std::sync::Arc;
+use std::time::Instant;
 use tracing::{error, info};
 
 pub(crate) mod errors;
@@ -76,27 +76,30 @@ fn generate_chunks(state: GlobalState) -> Result<(), BinaryError> {
     info!("No overworld spawn chunk found, generating spawn chunks...");
     // Generate a 12x12 chunk area around the spawn point
     let mut chunks = Vec::new();
+    let start = Instant::now();
     let radius = get_global_config().chunk_render_distance as i32;
     for x in -radius..=radius {
         for z in -radius..=radius {
             chunks.push((x, z));
         }
     }
-    let generated_chunks: Vec<Result<Chunk, WorldGenError>> = chunks
-        .iter()
-        .map(|(x, z)| {
-            let state = state.clone();
-            state.terrain_generator.generate_chunk(*x, *z)
-        })
-        .collect();
-    for chunk in generated_chunks {
-        let chunk = chunk.map_err(|e| {
-            error!("Error generating chunk: {:?}", e);
-            BinaryError::Custom("Error generating chunk".to_string())
-        })?;
-        state.world.save_chunk(chunk)?;
+    let mut batch = state.thread_pool.batch();
+    for (x, z) in chunks {
+        let state_clone = state.clone();
+        batch.execute(move || {
+            let chunk = state_clone.terrain_generator.generate_chunk(x, z);
+            if let Err(e) = chunk {
+                error!("Error generating chunk ({}, {}): {:?}", x, z, e);
+            } else {
+                let chunk = chunk.unwrap();
+                if let Err(e) = state_clone.world.save_chunk(chunk) {
+                    error!("Error saving chunk ({}, {}): {:?}", x, z, e);
+                }
+            }
+        });
     }
-    info!("Finished generating spawn chunks...");
+    batch.wait();
+    info!("Finished generating spawn chunks in {:?}", start.elapsed());
     Ok(())
 }
 
@@ -133,7 +136,7 @@ fn handle_import(import_args: ImportArgs) -> Result<(), BinaryError> {
     info!("Importing world...");
 
     // let config = get_global_config();
-    let mut world = World::new();
+    let mut world = World::new(get_global_config().database.db_path.clone().into());
 
     let root_path = get_root_path();
     let mut import_path = root_path.join(import_args.import_path);
@@ -155,9 +158,10 @@ fn handle_import(import_args: ImportArgs) -> Result<(), BinaryError> {
 
 fn create_state() -> Result<ServerState, BinaryError> {
     Ok(ServerState {
-        world: World::new(),
+        world: World::new(get_global_config().database.db_path.clone().into()),
         terrain_generator: WorldGenerator::new(0),
         shut_down: false.into(),
         players: DashMap::default(),
+        thread_pool: ThreadPool::new(),
     })
 }

src/bin/src/main.rs

@@ -42,7 +42,8 @@ pub fn handle(
                 pos.z as i32,
                 "overworld",
             )?;
-            if head_block.name == "minecraft:air" {
+            // Check if air
+            if head_block.0 == 0 {
                 move_to_spawn = false;
             }
             if move_to_spawn {

src/bin/src/packet_handlers/play_packets/chunk_batch_ack.rs

@@ -29,11 +29,21 @@ pub fn handle(
             match event.hand.0 {
                 0 => {
                     debug!("Placing block at {:?}", event.position);
-                    let block_clicked = state.0.clone().world.get_block_and_fetch(
+                    let mut chunk = match state.0.world.load_chunk(
+                        event.position.x >> 4,
+                        event.position.z >> 4,
+                        "overworld",
+                    ) {
+                        Ok(chunk) => chunk,
+                        Err(e) => {
+                            debug!("Failed to load chunk: {:?}", e);
+                            continue 'ev_loop;
+                        }
+                    };
+                    let block_clicked = chunk.get_block(
                         event.position.x,
                         event.position.y as i32,
                         event.position.z,
-                        "overworld",
                     )?;
                     trace!("Block clicked: {:?}", block_clicked);
                     // Use the face to determine the offset of the block to place
@@ -73,10 +83,9 @@ pub fn handle(
                         continue 'ev_loop;
                     }
                     let packet = BlockChangeAck {
-                        sequence: event.sequence.clone(),
+                        sequence: event.sequence,
                     };
                     conn.send_packet(packet)?;
-                    let mut chunk = state.0.world.load_chunk(x >> 4, z >> 4, "overworld")?;
 
                     chunk.set_block(
                         x & 0xF,
@@ -88,7 +97,7 @@ pub fn handle(
                         },
                     )?;
                     let ack_packet = BlockChangeAck {
-                        sequence: event.sequence.clone(),
+                        sequence: event.sequence,
                     };
                     // Make this use the much more efficient block change packet
                     let chunk_packet = ChunkAndLightData::from_chunk(&chunk)?;

src/bin/src/packet_handlers/play_packets/place_block.rs

@@ -6,9 +6,9 @@ use ferrumc_net::packets::outgoing::block_update::BlockUpdate;
 use ferrumc_net::PlayerActionReceiver;
 use ferrumc_net_codec::net_types::var_int::VarInt;
 use ferrumc_state::GlobalStateResource;
-use ferrumc_world::chunk_format::BLOCK2ID;
+use ferrumc_world::block_id::BlockId;
 use ferrumc_world::vanilla_chunk_format::BlockData;
-use tracing::{debug, error};
+use tracing::{debug, error, trace};
 
 pub fn handle(
     events: Res<PlayerActionReceiver>,
@@ -20,11 +20,21 @@ pub fn handle(
         let res: Result<(), BinaryError> = try {
             match event.status.0 {
                 0 => {
-                    let mut chunk = state.0.clone().world.load_chunk(
+                    let mut chunk = match state.0.clone().world.load_chunk(
                         event.location.x >> 4,
                         event.location.z >> 4,
                         "overworld",
-                    )?;
+                    ) {
+                        Ok(chunk) => chunk,
+                        Err(e) => {
+                            trace!("Chunk not found, generating new chunk: {:?}", e);
+                            state
+                                .0
+                                .clone()
+                                .terrain_generator
+                                .generate_chunk(event.location.x >> 4, event.location.z >> 4)?
+                        }
+                    };
                     let block = chunk.get_block(
                         event.location.x,
                         event.location.y as i32,
@@ -38,22 +48,20 @@ pub fn handle(
                     );
                     chunk.set_block(relative_x, relative_y, relative_z, BlockData::default())?;
                     // Save the chunk to disk
-                    state.0.world.save_chunk(chunk.clone())?;
+                    state.0.world.save_chunk(chunk)?;
                     for (eid, conn) in query {
                         if !conn.running.load(std::sync::atomic::Ordering::Relaxed) {
                             continue;
                         }
                         // If the player is the one who placed the block, send the BlockChangeAck packet
                         let block_update_packet = BlockUpdate {
                             location: event.location.clone(),
-                            block_id: VarInt::from(*BLOCK2ID.get(&BlockData::default()).expect(
-                                "BlockData::default() should always have a corresponding block ID",
-                            )),
+                            block_id: VarInt::from(BlockId::default()),
                         };
                         conn.send_packet(block_update_packet)?;
                         if eid == trigger_eid {
                             let ack_packet = BlockChangeAck {
-                                sequence: event.sequence.clone(),
+                                sequence: event.sequence,
                             };
                             conn.send_packet(ack_packet)?;
                         }

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

@@ -7,7 +7,8 @@ use ferrumc_net::packets::outgoing::chunk_batch_start::ChunkBatchStart;
 use ferrumc_net::packets::outgoing::set_center_chunk::SetCenterChunk;
 use ferrumc_net_codec::net_types::var_int::VarInt;
 use ferrumc_state::GlobalState;
-use tracing::trace;
+use ferrumc_world_gen::errors::WorldGenError::WorldError;
+use tracing::{error, trace};
 
 pub fn send_chunks(
     state: GlobalState,
@@ -33,25 +34,43 @@ pub fn send_chunks(
 
     let mut chunks_sent = 0;
 
+    let mut batch = state.thread_pool.batch();
+
     for (x, z, dim) in chunk_coords {
-        let chunk = if state.world.chunk_exists(x, z, &dim)? {
-            state.world.load_chunk(x, z, &dim)?
-        } else {
-            trace!("Generating chunk {}x{} in dimension {}", x, z, dim);
-            let generated_chunk = state.terrain_generator.generate_chunk(x, z)?;
-            // TODO: Remove this clone
-            state.world.save_chunk(generated_chunk.clone())?;
-            generated_chunk
-        };
-        assert_eq!(chunk.x, x);
-        assert_eq!(chunk.z, z);
-        let packet = ChunkAndLightData::from_chunk(&chunk)?;
-        conn.send_packet(packet)?;
-        // This never actually gets emptied out so if someone goes to enough new chunks and doesn't
-        // leave the server, this will eventually run out of memory. Should probably be fixed.
-        // recv.seen.insert((x, z, dim.clone()));
-        // recv.needs_reload.remove(&(x, z, dim));
-        chunks_sent += 1;
+        let state_clone = state.clone();
+        batch.execute(move || {
+            let chunk = if state_clone.world.chunk_exists(x, z, &dim).unwrap_or(false) {
+                state_clone
+                    .world
+                    .load_chunk(x, z, &dim)
+                    .map_err(WorldError)?
+            } else {
+                trace!("Generating chunk {}x{} in dimension {}", x, z, dim);
+                // Don't bother saving the chunk if it hasn't been edited yet
+                state_clone.terrain_generator.generate_chunk(x, z)?
+            };
+            Ok((ChunkAndLightData::from_chunk(&chunk), x, z))
+        })
+    }
+
+    let packets = batch.wait();
+
+    for packet in packets {
+        match packet {
+            Ok((packet, x, z)) => {
+                trace!("Sending chunk data for chunk at coordinates ({}, {})", x, z);
+                conn.send_packet(packet?)?;
+                chunks_sent += 1;
+            }
+            Err(WorldError(e)) => {
+                error!("Failed to generate or load chunk: {:?}", e);
+                continue;
+            }
+            Err(e) => {
+                error!("Unexpected error while processing chunk: {:?}", e);
+                continue;
+            }
+        }
     }
 
     let batch_end_packet = ChunkBatchFinish {

src/bin/src/systems/send_chunks.rs

@@ -8,3 +8,4 @@ bevy_ecs = { workspace = true }
 ferrumc-world = { workspace = true }
 ferrumc-world-gen = { workspace = true }
 dashmap = { workspace = true }
+ferrumc-threadpool = { workspace = true }

src/lib/core/state/Cargo.toml

@@ -1,5 +1,6 @@
 use bevy_ecs::prelude::Resource;
 use dashmap::DashMap;
+use ferrumc_threadpool::ThreadPool;
 use ferrumc_world::World;
 use ferrumc_world_gen::WorldGenerator;
 use std::sync::atomic::AtomicBool;
@@ -10,6 +11,7 @@ pub struct ServerState {
     pub terrain_generator: WorldGenerator,
     pub shut_down: AtomicBool,
     pub players: DashMap<u128, String>,
+    pub thread_pool: ThreadPool,
 }
 
 pub type GlobalState = Arc<ServerState>;

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

@@ -10,7 +10,7 @@ use tokio::io::AsyncRead;
 use tokio::io::AsyncWriteExt;
 use tokio::io::{AsyncReadExt, AsyncWrite};
 
-#[derive(Debug, Encode, Decode, Clone, DeepSizeOf, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Encode, Decode, Clone, DeepSizeOf, PartialEq, Eq, PartialOrd, Ord, Copy)]
 pub struct VarInt(pub i32);
 
 mod adapters {