Introduce Chunk Transfer and Processing Limits

.cargo/config.toml

@@ -4,4 +4,6 @@ BEVY_ASSET_ROOT = "."
 [alias]
 rc = 'run --bin client'
 rs = 'run --bin server'
+tc = 'run --bin client --features bevy/trace_tracy'
+ts = 'run --bin server --features bevy/trace_tracy'
 t = 'test'

src/client/player/systems/controller.rs

@@ -4,7 +4,7 @@ use crate::prelude::*;
 const SPAWN_POINT: Vec3 = Vec3::new(0.0, 1.0, 0.0);
 
 #[cfg(all(not(feature = "skip_terrain"), not(feature = "lock_player")))]
-const SPAWN_POINT: Vec3 = Vec3::new(0.0, 64.0, 0.0);
+const SPAWN_POINT: Vec3 = Vec3::new(0.0, 43.0, 0.0); // TODO: determine terrain height at 0,0
 
 #[cfg(all(not(feature = "skip_terrain"), feature = "lock_player"))]
 const SPAWN_POINT: Vec3 = Vec3::new(128.0, 96.0, -128.0);

src/client/terrain/systems.rs

@@ -53,11 +53,17 @@ pub fn generate_world_system(
 
     info!("Sending chunk requests for chunks");
 
-    let chunks = chunk_manager.instantiate_new_chunks(IVec3::ZERO, render_distance);
+    let origin = IVec3::ZERO;
+    let chunks = chunk_manager.instantiate_new_chunks(origin, render_distance);
 
-    let positions: Vec<IVec3> = chunks.into_iter().map(|chunk| chunk.position).collect();
+    let mut positions: Vec<IVec3> = chunks.into_iter().map(|chunk| chunk.position).collect();
+    positions.sort_by(|a, b| {
+        (a - origin)
+            .length_squared()
+            .cmp(&(b - origin).length_squared())
+    });
 
-    let batched_positions = positions.chunks(16);
+    let batched_positions = positions.chunks(32);
     assert!(batched_positions.len() > 0, "Batched positions is empty");
 
     batched_positions.enumerate().for_each(|(index, batch)| {

src/server/networking/systems.rs

@@ -4,11 +4,10 @@ pub fn receive_message_system(
     mut server: ResMut<RenetServer>,
     mut player_states: ResMut<player_resources::PlayerStates>,
     mut past_block_updates: ResMut<terrain_resources::PastBlockUpdates>,
-    chunk_manager: ResMut<ChunkManager>,
+    mut request_queue: ResMut<terrain_resources::ClientChunkRequests>,
     #[cfg(feature = "chat")] mut chat_message_events: MessageWriter<
         chat_events::PlayerChatMessageSendEvent,
     >,
-    generator: Res<terrain_resources::Generator>,
 ) {
     for client_id in server.clients_id() {
         while let Some(message) = server.receive_message(client_id, DefaultChannel::ReliableOrdered)
@@ -64,30 +63,7 @@ pub fn receive_message_system(
                         positions, client_id
                     );
 
-                    let chunks: Vec<Chunk> = positions
-                        .into_par_iter()
-                        .map(|position| {
-                            let chunk = chunk_manager.get_chunk(position);
-
-                            match chunk {
-                                Some(chunk) => *chunk,
-                                None => {
-                                    let mut chunk = Chunk::new(position);
-                                    generator.generate_chunk(&mut chunk);
-                                    chunk
-                                }
-                            }
-                        })
-                        .collect();
-
-                    let message =
-                        bincode::serialize(&NetworkingMessage::ChunkBatchResponse(chunks));
-
-                    server.send_message(
-                        client_id,
-                        DefaultChannel::ReliableUnordered,
-                        message.unwrap(),
-                    );
+                    request_queue.enqueue_bulk(client_id, &mut positions.into());
                 }
                 _ => {
                     warn!("Received unknown message type. (ReliableUnordered)");
@@ -102,6 +78,7 @@ pub fn handle_events_system(
     mut server_events: MessageReader<ServerEvent>,
     mut player_states: ResMut<player_resources::PlayerStates>,
     past_block_updates: Res<terrain_resources::PastBlockUpdates>,
+    mut request_queue: ResMut<terrain_resources::ClientChunkRequests>,
     #[cfg(feature = "chat")] mut chat_message_events: MessageWriter<
         chat_events::PlayerChatMessageSendEvent,
     >,
@@ -153,6 +130,8 @@ pub fn handle_events_system(
                 println!("Client {client_id} disconnected: {reason}");
                 player_states.players.remove(client_id);
 
+                request_queue.remove(*client_id);
+
                 #[cfg(feature = "chat")]
                 chat_message_events.write(chat_events::PlayerChatMessageSendEvent {
                     client_id: SERVER_MESSAGE_ID,

src/server/terrain/mod.rs

@@ -13,7 +13,9 @@ impl Plugin for TerrainPlugin {
         app.add_message::<terrain_events::BlockUpdateEvent>();
         app.insert_resource(resources::PastBlockUpdates::new());
         app.add_systems(Startup, terrain_systems::setup_world_system);
+        app.add_systems(Update, terrain_systems::process_user_chunk_requests_system);
         app.insert_resource(resources::Generator::default());
+        app.insert_resource(resources::ClientChunkRequests::default());
 
         #[cfg(feature = "generator_visualizer")]
         {

src/server/terrain/resources.rs

@@ -1,7 +1,34 @@
+use std::collections::VecDeque;
+
 use crate::prelude::*;
 
 use terrain_events::BlockUpdateEvent;
 
+#[derive(Resource, Default)]
+pub struct ClientChunkRequests {
+    queues: HashMap<ClientId, VecDeque<IVec3>>,
+}
+
+impl ClientChunkRequests {
+    pub fn enqueue_bulk(&mut self, client_id: ClientId, chunk_positions: &mut VecDeque<IVec3>) {
+        self.queues
+            .entry(client_id)
+            .or_default()
+            .append(chunk_positions);
+    }
+
+    pub fn remove(&mut self, client_id: ClientId) {
+        self.queues.remove(&client_id);
+    }
+
+    pub fn retain<F>(&mut self, f: F)
+    where
+        F: FnMut(&ClientId, &mut VecDeque<IVec3>) -> bool,
+    {
+        self.queues.retain(f)
+    }
+}
+
 #[derive(Resource)]
 pub struct PastBlockUpdates {
     pub updates: Vec<BlockUpdateEvent>,

src/server/terrain/systems.rs

@@ -1,3 +1,5 @@
+use std::cmp::min;
+
 use crate::prelude::*;
 
 pub fn setup_world_system(
@@ -18,6 +20,50 @@ pub fn setup_world_system(
     chunk_manager.insert_chunks(chunks);
 }
 
+pub fn process_user_chunk_requests_system(
+    mut requests: ResMut<terrain_resources::ClientChunkRequests>,
+    chunk_manager: Res<ChunkManager>,
+    mut server: ResMut<RenetServer>,
+    generator: Res<terrain_resources::Generator>,
+) {
+    const MAX_REQUESTS_PER_CYCLE_PER_PLAYER: usize = 5;
+
+    requests.retain(|client_id, positions| {
+        if positions.is_empty() {
+            return false;
+        }
+
+        let take_count = min(MAX_REQUESTS_PER_CYCLE_PER_PLAYER, positions.len());
+        let positions_to_process: Vec<IVec3> = positions.drain(0..take_count).collect();
+
+        let chunks = positions_to_process
+            .into_par_iter()
+            .map(|position| {
+                let chunk = chunk_manager.get_chunk(position);
+
+                match chunk {
+                    Some(chunk) => *chunk,
+                    None => {
+                        let mut chunk = Chunk::new(position);
+                        generator.generate_chunk(&mut chunk);
+                        chunk
+                    }
+                }
+            })
+            .collect();
+
+        let message = bincode::serialize(&NetworkingMessage::ChunkBatchResponse(chunks));
+
+        server.send_message(
+            *client_id,
+            DefaultChannel::ReliableUnordered,
+            message.unwrap(),
+        );
+
+        !positions.is_empty()
+    });
+}
+
 #[cfg(feature = "generator_visualizer")]
 pub use visualizer::*;