refactor comments

src/client_handler.rs

@@ -41,10 +41,11 @@ impl Listener for NetworkListener {
     fn listen(port: u16) -> Result<()> {
         // Create the bind address string
         let bind_addr = format!("0.0.0.0:{}", port);
+
         // Attempt to bind the UDP socket to the address
         let socket = UdpSocket::bind(bind_addr);
         let socket = match socket {
-            Ok(s) => s, // If successful, use the socket
+            Ok(s) => s,
             Err(e) => {
                 // If there's an error, return a BindError
                 return Err(BindError {
@@ -60,14 +61,19 @@ impl Listener for NetworkListener {
         loop {
             // Buffer to store incoming data
             let mut data = [0; 1_048_576];
+
             // Receive data from the socket
             let (amt, src) = socket.recv_from(&mut data).expect("Didn't receive data");
+
             // Print the amount of data received and the source address
             println!("Received {} bytes from {}", amt, src);
+
             // Slice the buffer to the actual amount of data received
             let data = &mut data[..amt];
+
             // Deserialize the data into a Message
             let msg = bincode::deserialize::<Message>(data).expect("Failed to deserialize");
+
             // Handle the deserialized message
             NetworkListener::handle_message(msg);
         }

src/dispatcher.rs

@@ -20,8 +20,10 @@ pub struct NetworkDispatcher;
 impl NetworkDispatcher {
     // Load a sound file and return a Decoder
     fn load_sound(path: String) -> Decoder<BufReader<File>> {
-        let file = BufReader::new(File::open(path).unwrap()); // Open the file
-        Decoder::new(file).unwrap() // Decode the file
+        // Open the file
+        let file = BufReader::new(File::open(path).unwrap());
+        // Decode the file
+        Decoder::new(file).unwrap()
     }
 }
 
@@ -39,23 +41,28 @@ impl Dispatcher for NetworkDispatcher {
         let channels = source.channels();
         let sample_rate = source.sample_rate();
         let duration = source.total_duration().unwrap();
-        let chunk_len = Duration::from_millis(200); // Length of each chunk to send
+        // Length of each chunk to send
+        let chunk_len = Duration::from_millis(200);
 
-        let mut offset = Duration::from_secs(0); // Initial offset
+        // Initial offset
+        let mut offset = Duration::from_secs(0);
 
         // Iterate over each address
         for addr in addrs {
+            // Skip empty addresses
             if addr.is_empty() {
-                continue; // Skip empty addresses
+                continue;
             }
 
-            let source = source.clone(); // Clone the source for each thread
+            // Clone the source for each thread
+            let source = source.clone();
 
             // Spawn a new thread for each address
             thread::spawn(move || {
                 // Bind to a local UDP socket
                 let sock = UdpSocket::bind("0.0.0.0:0").expect("Failed to bind");
-                sock.connect(addr.clone()).expect("Failed to connect"); // Connect to the address
+                // Connect to the address
+                sock.connect(addr.clone()).expect("Failed to connect");
 
                 // Loop until the entire duration is covered
                 while offset < duration {
@@ -66,11 +73,13 @@ impl Dispatcher for NetworkDispatcher {
                         .take_duration(chunk_len)
                         .collect::<Vec<i16>>();
 
-                    offset += chunk_len; // Update the offset
+                    // Update the offset
+                    offset += chunk_len;
 
                     // Create a PlaySound message
                     let msg = Message::PlaySound(PlaySound {
-                        timestamp: (now + offset).as_micros(), // Timestamp for synchronization
+                        // Timestamp for synchronization
+                        timestamp: (now + offset).as_micros(),
                         channels: channels,
                         sample_rate: sample_rate,
                         sound_data: sound_data,

src/main.rs

@@ -1,4 +1,5 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // Hide console window on Windows in release mode
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+// Hide console window on Windows in release mode
 
 // Import necessary modules and crates
 use client_handler::{Listener, NetworkListener};
@@ -18,7 +19,8 @@ mod ui_app;
 fn main() -> eframe::Result {
     // Define options for the eframe application
     let options = eframe::NativeOptions {
-        viewport: egui::ViewportBuilder::default().with_inner_size([700.0, 400.0]), // Set initial window size
+        // Set initial window size
+        viewport: egui::ViewportBuilder::default().with_inner_size([700.0, 400.0]),
         ..Default::default()
     };
 
@@ -29,13 +31,15 @@ fn main() -> eframe::Result {
         match result {
             Ok(_) => {}
             Err(e) => {
-                eprintln!("Failed to bind: {}", e.message); // Print error message if binding fails
+                // Print error message if binding fails
+                eprintln!("Failed to bind: {}", e.message);
                 // Try with port 3001 if port 3000 fails
                 let result = NetworkListener::listen(3001);
                 match result {
                     Ok(_) => {}
                     Err(e) => {
-                        eprintln!("Failed to bind again: {}", e.message); // Print error message if binding fails again
+                        // Print error message if binding fails again
+                        eprintln!("Failed to bind again: {}", e.message);
                     }
                 }
             }
@@ -44,13 +48,17 @@ fn main() -> eframe::Result {
 
     // Run the eframe application
     eframe::run_native(
-        "My egui App", // Application title
-        options,       // Application options
+        // Application title
+        "My egui App",
+        // Application options
+        options,
         Box::new(|cc| {
             // This gives us image support:
-            egui_extras::install_image_loaders(&cc.egui_ctx); // Install image loaders for egui context
+            // Install image loaders for egui context
+            egui_extras::install_image_loaders(&cc.egui_ctx);
 
-            Ok(Box::<UIApp>::default()) // Initialize the UI application
+            // Initialize the UI application
+            Ok(Box::<UIApp>::default())
         }),
     )
 }

src/protocol.rs

@@ -1,16 +1,25 @@
-use serde::{Deserialize, Serialize}; // Importing necessary traits from serde for serialization and deserialization
+use serde::{Deserialize, Serialize};
+
+// Importing necessary traits from serde for serialization and deserialization
 
 // Define an enum called Message which can hold different types of messages
-#[derive(Serialize, Deserialize, Debug)] // Automatically generate code for serialization, deserialization, and debugging
+#[derive(Serialize, Deserialize, Debug)]
+// Automatically generate code for serialization, deserialization, and debugging
 pub enum Message {
-    PlaySound(PlaySound), // A variant of the Message enum that holds a PlaySound struct
+    PlaySound(PlaySound),
+    // A variant of the Message enum that holds a PlaySound struct
 }
 
 // Define a struct called PlaySound which represents a sound to be played
-#[derive(Serialize, Deserialize, Debug)] // Automatically generate code for serialization, deserialization, and debugging
+#[derive(Serialize, Deserialize, Debug)]
+// Automatically generate code for serialization, deserialization, and debugging
 pub struct PlaySound {
-    pub timestamp: u128,      // The timestamp when the sound should be played
-    pub channels: u16,        // The number of audio channels (e.g., 2 for stereo)
-    pub sample_rate: u32,     // The sample rate of the audio (e.g., 44100 for 44.1 kHz)
-    pub sound_data: Vec<i16>, // The actual sound data as a vector of 16-bit integers
+    pub timestamp: u128,
+    // The timestamp when the sound should be played
+    pub channels: u16,
+    // The number of audio channels (e.g., 2 for stereo)
+    pub sample_rate: u32,
+    // The sample rate of the audio (e.g., 44100 for 44.1 kHz)
+    pub sound_data: Vec<i16>,
+    // The actual sound data as a vector of 16-bit integers
 }