Add terrain ready event, refactor

Author: CuddlyBunion341

src/client/networking/systems.rs

@@ -8,6 +8,7 @@ pub fn receive_message_system(
     mut block_update_events: ResMut<Events<terrain_events::BlockUpdateEvent>>,
     mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
     mut chunk_mesh_events: ResMut<Events<terrain_events::ChunkMeshUpdateEvent>>,
+    mut spawn_ready_events: ResMut<Events<terrain_events::SpawnAreaReadyEvent>>,
 ) {
     while let Some(message) = client.receive_message(DefaultChannel::ReliableOrdered) {
         let message = bincode::deserialize(&message).unwrap();
@@ -59,6 +60,14 @@ pub fn receive_message_system(
                         chunk_mesh_events.send(terrain_events::ChunkMeshUpdateEvent {
                             position: chunk_position,
                         });
+
+                        if chunk_position.eq(&Vec3 {
+                            x: 0.0,
+                            y: 0.0,
+                            z: 0.0,
+                        }) {
+                            spawn_ready_events.send(terrain_events::SpawnAreaReadyEvent {});
+                        }
                     }
                 }
                 lib::NetworkingMessage::PlayerSync(event) => {

src/client/player/mod.rs

@@ -28,16 +28,11 @@ impl Plugin for PlayerPlugin {
         app.add_event::<player_events::PlayerColliderUpdateEvent>();
         app.insert_resource(player_resources::BlockSelection::new());
         app.insert_resource(player_resources::LastPlayerPosition::new());
-        app.add_systems(
-            Startup,
-            (
-                player_systems::setup_controller_system,
-                player_systems::setup_highlight_cube_system,
-            ),
-        );
+        app.add_systems(Startup, (player_systems::setup_highlight_cube_system,));
         app.add_systems(
             Update,
             (
+                player_systems::setup_controller_on_area_ready_system,
                 player_systems::handle_controller_movement_system,
                 player_systems::manage_cursor_system,
                 player_systems::handle_mouse_events_system,

src/client/player/systems/controller.rs

@@ -2,7 +2,15 @@ use crate::prelude::*;
 
 const SPAWN_POINT: Vec3 = Vec3::new(0.0, 20.0, 0.0);
 
-pub fn setup_controller_system(mut commands: Commands, mut window: Query<&mut Window>) {
+pub fn setup_controller_on_area_ready_system(
+    mut commands: Commands,
+    mut window: Query<&mut Window>,
+    mut spawn_area_ready_events: EventReader<terrain_events::SpawnAreaReadyEvent>,
+) {
+    if spawn_area_ready_events.read().count() == 0 {
+        return;
+    }
+
     let mut window = window.single_mut();
     window.title = String::from("Minimal FPS Controller Example");
 

src/client/terrain/events.rs

@@ -1,5 +1,8 @@
 use crate::prelude::*;
 
+#[derive(Event)]
+pub struct SpawnAreaReadyEvent;
+
 #[derive(Event)]
 pub struct ChunkMeshUpdateEvent {
     pub position: Vec3,

src/client/terrain/mod.rs

@@ -15,7 +15,8 @@ impl Plugin for TerrainPlugin {
         app.insert_resource(util::TextureManager::new());
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.add_event::<terrain_events::ChunkMeshUpdateEvent>();
-        app.add_systems(Startup, terrain_systems::setup_world_system);
+        app.add_event::<terrain_events::SpawnAreaReadyEvent>();
+        app.add_systems(Startup, terrain_systems::generate_world_system);
         app.add_systems(Update, terrain_systems::handle_chunk_mesh_update_events);
     }
 }

src/client/terrain/resources.rs

@@ -38,6 +38,23 @@ impl ChunkManager {
         chunks
     }
 
+    pub fn instantiate_new_chunks(
+        &mut self,
+        position: Vec3,
+        render_distance: i32,
+    ) -> Vec<lib::Chunk> {
+        let chunks = Self::instantiate_chunks(position, render_distance);
+
+        chunks
+            .into_iter()
+            .filter(|chunk| {
+                let chunk_position = chunk.position;
+                let chunk = self.get_chunk(chunk_position);
+                chunk.is_some()
+            })
+            .collect()
+    }
+
     pub fn insert_chunk(&mut self, chunk: lib::Chunk) {
         self.chunks
             .insert(Self::position_to_key(chunk.position), chunk);

src/client/terrain/systems.rs

@@ -1,15 +1,30 @@
 use crate::prelude::*;
 
-pub fn setup_world_system(mut client: ResMut<RenetClient>) {
-    let render_distance = 4;
+pub fn prepare_spawn_area_system(mut client: ResMut<RenetClient>) {
+    let render_distance = 2;
 
-    info!("Sending chunk requests for chunks");
+    info!("Sending chunk requests for spawn area");
 
     let chunks = terrain_resources::ChunkManager::instantiate_chunks(
         Vec3::new(0.0, 0.0, 0.0),
         render_distance,
     );
 
+    let positions: Vec<Vec3> = chunks.into_iter().map(|chunk| chunk.position).collect();
+    let message = bincode::serialize(&NetworkingMessage::ChunkBatchRequest(positions));
+    client.send_message(DefaultChannel::ReliableUnordered, message.unwrap());
+}
+
+pub fn generate_world_system(
+    mut client: ResMut<RenetClient>,
+    mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
+) {
+    let render_distance = 6;
+
+    info!("Sending chunk requests for chunks");
+
+    let chunks = chunk_manager.instantiate_new_chunks(Vec3::new(0.0, 0.0, 0.0), render_distance);
+
     let positions: Vec<Vec3> = chunks.into_iter().map(|chunk| chunk.position).collect();
 
     let batched_positions = positions.chunks(32);