Fix linter

Author: CuddlyBunion341

src/client/networking/systems.rs

@@ -22,7 +22,7 @@ pub fn receive_message_system(
             lib::NetworkingMessage::PlayerLeave(event) => {
                 player_despawn_events
                     .send(remote_player_events::RemotePlayerDespawnedEvent { client_id: event });
-                }
+            }
             lib::NetworkingMessage::BlockUpdate { position, block } => {
                 debug!("Client received block update message: {:?}", position);
                 block_update_events.send(terrain_events::BlockUpdateEvent {
@@ -64,7 +64,7 @@ pub fn receive_message_system(
                 lib::NetworkingMessage::PlayerSync(event) => {
                     player_sync_events
                         .send(remote_player_events::RemotePlayerSyncEvent { players: event });
-                    }
+                }
                 _ => {
                     warn!("Received unknown message type. (ReliableUnordered)");
                 }

src/client/terrain/resources.rs

@@ -156,7 +156,7 @@ mod tests {
         let position = Vec3::new(0.0, 0.0, 0.0);
         let chunk = Chunk::new(position);
 
-        chunk_manager.set_chunk(position, chunk.clone());
+        chunk_manager.set_chunk(position, chunk);
         let retrieved_chunk = chunk_manager.get_chunk(position).unwrap();
         assert_eq!(retrieved_chunk.position, chunk.position);
     }

src/client/terrain/systems.rs

@@ -16,7 +16,10 @@ pub fn setup_world_system(mut client: ResMut<RenetClient>) {
 
     batched_positions.for_each(|batch| {
         let request_positions = batch.to_vec();
-        info!("Sending chunk batch request for {:?}", request_positions.len());
+        info!(
+            "Sending chunk batch request for {:?}",
+            request_positions.len()
+        );
         let message = bincode::serialize(&NetworkingMessage::ChunkBatchRequest(request_positions));
         client.send_message(DefaultChannel::ReliableUnordered, message.unwrap());
     });
@@ -34,7 +37,10 @@ pub fn handle_chunk_mesh_update_events(
     texture_manager: ResMut<terrain_util::TextureManager>,
 ) {
     for event in chunk_mesh_update_events.read() {
-        info!("Received chunk mesh update event for chunk {:?}", event.position);
+        info!(
+            "Received chunk mesh update event for chunk {:?}",
+            event.position
+        );
         let chunk_option = chunk_manager.get_chunk(event.position);
         match chunk_option {
             Some(chunk) => {
@@ -119,18 +125,18 @@ fn spawn_chunk(
     );
 
     commands.spawn((
-            MaterialMeshBundle {
-                mesh: meshes.add(mesh),
-                transform,
-                material,
-                ..default()
-            },
-            terrain_components::ChunkMesh {
-                key: [
-                    chunk.position.x as i32,
-                    chunk.position.y as i32,
-                    chunk.position.z as i32,
-                ],
-            },
+        MaterialMeshBundle {
+            mesh: meshes.add(mesh),
+            transform,
+            material,
+            ..default()
+        },
+        terrain_components::ChunkMesh {
+            key: [
+                chunk.position.x as i32,
+                chunk.position.y as i32,
+                chunk.position.z as i32,
+            ],
+        },
     ));
 }

src/server/networking/systems.rs

@@ -38,28 +38,33 @@ pub fn receive_message_system(
                     positions, client_id
                 );
 
-                let chunks: Vec<Chunk> = positions.into_iter().map(|position| {
-                    let chunk = chunk_manager.get_chunk(position);
+                let chunks: Vec<Chunk> = positions
+                    .into_iter()
+                    .map(|position| {
+                        let chunk = chunk_manager.get_chunk(position);
 
-                    match chunk {
-                        Some(chunk) => {
-                            return chunk.clone();
-                        }
-                        None => {
-                            let mut chunk = lib::Chunk::new(position);
+                        match chunk {
+                            Some(chunk) => *chunk,
+                            None => {
+                                let mut chunk = lib::Chunk::new(position);
 
-                            let generator = terrain_util::generator::Generator::new(0);
+                                let generator = terrain_util::generator::Generator::new(0);
 
-                            generator.generate_chunk(&mut chunk);
+                                generator.generate_chunk(&mut chunk);
 
-                            return chunk.clone();
+                                chunk
+                            }
                         }
-                    }
-                }).collect();
-
-                let message = bincode::serialize(&lib::NetworkingMessage::ChunkBatchResponse(chunks));
-                server.send_message(client_id, DefaultChannel::ReliableUnordered, message.unwrap());
+                    })
+                    .collect();
 
+                let message =
+                    bincode::serialize(&lib::NetworkingMessage::ChunkBatchResponse(chunks));
+                server.send_message(
+                    client_id,
+                    DefaultChannel::ReliableUnordered,
+                    message.unwrap(),
+                );
             }
             _ => {
                 warn!("Received unknown message type. (ReliableUnordered)");

src/server/terrain/resources.rs

@@ -174,7 +174,7 @@ mod tests {
         let position = Vec3::new(0.0, 0.0, 0.0);
         let chunk = Chunk::new(position);
 
-        chunk_manager.set_chunk(position, chunk.clone());
+        chunk_manager.set_chunk(position, chunk);
         let retrieved_chunk = chunk_manager.get_chunk(position).unwrap();
         assert_eq!(retrieved_chunk.position, chunk.position);
     }