Merge branch 'feature-cleanup'

Locating the among us folder and launching the app are one in the same, need GUI work to allow it to update after location

More and changed log messages

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "town-of-us-updater"
-version = "1.0.0"
+version = "2.0.0"
 edition = "2021"
 build = "src/build.rs"
 

src/among_us_version.rs

@@ -0,0 +1,39 @@
+use std::fmt;
+
+#[derive(Ord, PartialOrd, Eq, PartialEq)]
+pub struct AmongUsVersion {
+    year: i32,
+    month: i32,
+    day: i32,
+}
+
+impl fmt::Display for AmongUsVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}.{}.{}", self.year, self.month, self.day)
+    }
+}
+
+impl From<&str> for AmongUsVersion {
+    fn from(s: &str) -> AmongUsVersion {
+        // Ignore a prepending "v"
+        let tmp_str = s.replace("v", "");
+
+        let v: Vec<&str> = tmp_str.split('.').collect();
+
+        AmongUsVersion {
+            year: v[0].parse().unwrap(),
+            month: v[1].parse().unwrap(),
+            day: v[2].parse().unwrap(),
+        }
+    }
+}
+
+impl From<(i32, i32, i32)> for AmongUsVersion {
+    fn from(s: (i32, i32, i32)) -> AmongUsVersion {
+        AmongUsVersion {
+            year: s.0,
+            month: s.1,
+            day: s.2,
+        }
+    }
+}

src/main.rs

@@ -1,61 +1,43 @@
-use std::cell::RefCell;
+// Modules
-use std::path::{Path, PathBuf};
+mod among_us_version;
-use std::rc::Rc;
+
-use std::str;
+// Uses
-use std::*;
+use among_us_version::*;
+
+use std::{cell::RefCell, fs, io, path::Path, path::PathBuf, process, rc::Rc, str};
 
-use druid::widget::*;
-use druid::{
-    commands, AppDelegate, AppLauncher, Application, Data, DelegateCtx, Env, FileDialogOptions,
-    Handled, Target, WidgetExt, WindowDesc,
-};
 use fs_extra::{copy_items, dir};
+
 use regex::Regex;
 
+// GUI stuff
+use druid::{
+    commands, widget::*, AppDelegate, AppLauncher, Application, Data, DelegateCtx, Env,
+    FileDialogOptions, Handled, Target, WidgetExt, WindowDesc,
+};
+
 struct Delegate;
 
 #[derive(Data, Clone)]
 struct AppData {
     pub among_us_path: Rc<RefCell<String>>,
+    pub installs_path: String,
 }
 
-static AMONG_US_APPID: &'static str = "945360";
+static AMONG_US_APPID: &str = "945360";
-
-#[derive(Ord, PartialOrd, Eq, PartialEq)]
-struct AmongUsVersion {
-    year: i32,
-    month: i32,
-    day: i32,
-}
-
-impl fmt::Display for AmongUsVersion {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}.{}.{}", self.year, self.month, self.day)
-    }
-}
-
-impl From<&str> for AmongUsVersion {
-    fn from(s: &str) -> AmongUsVersion {
-        let v: Vec<&str> = s.split(".").collect();
-        AmongUsVersion {
-            year: i32::from_str_radix(v[0], 10).unwrap(),
-            month: i32::from_str_radix(v[1], 10).unwrap(),
-            day: i32::from_str_radix(v[2], 10).unwrap(),
-        }
-    }
-}
 
 fn attempt_run_among_us(install_path: &Path) {
-    let executable_path: path::PathBuf = [install_path.to_str().unwrap(), "Among Us.exe"]
+    let executable_path: PathBuf = [install_path.to_str().unwrap(), "Among Us.exe"]
         .iter()
         .collect();
 
-    std::process::Command::new(executable_path.to_str().unwrap())
+    process::Command::new(executable_path.to_str().unwrap())
         .spawn()
         .unwrap();
 }
 
 fn unmod_among_us_folder(folder_path: &Path) {
+    println!("Unmodding Among Us...");
     let doorstop_path: PathBuf = [folder_path.to_str().unwrap(), "doorstop_config.ini"]
         .iter()
         .collect();
@@ -65,6 +47,7 @@ fn unmod_among_us_folder(folder_path: &Path) {
     let winhttp_path: PathBuf = [folder_path.to_str().unwrap(), "winhttp.dll"]
         .iter()
         .collect();
+
     let bepinex_path: PathBuf = [folder_path.to_str().unwrap(), "BepInEx"].iter().collect();
     let mono_path: PathBuf = [folder_path.to_str().unwrap(), "mono"].iter().collect();
     fs::remove_file(doorstop_path).unwrap_or_default();
@@ -144,6 +127,7 @@ impl AppDelegate<AppData> for Delegate {
             println!("{}", buf.to_str().unwrap());
             println!("Handled!");
             Application::global().quit();
+
             return Handled::Yes;
         }
         Handled::No
@@ -157,7 +141,6 @@ async fn main() {
 
     println!("Updater Version: {}", version);
     get_latest_updater_version().await.unwrap();
-    //let _version_check_thread_handle = thread::spawn(move || get_latest_updater_version());
 
     // CREATE PROGRAM DIRECTORY
     let mut data_path = dirs::data_dir().unwrap();
@@ -168,25 +151,28 @@ async fn main() {
     installs_path.push("installs");
     fs::create_dir(installs_path.clone()).unwrap_or(());
 
+    let app_data: AppData = AppData {
+        among_us_path: Rc::new(RefCell::new(String::from(""))),
+        installs_path: String::from(""),
+    };
+
+    let mut root_column: druid::widget::Flex<AppData> = druid::widget::Flex::column();
+
     // DETERMINE AMONG US VERSION
 
-    let mut among_us_folder = path::PathBuf::new();
+    let mut among_us_folder = PathBuf::new();
 
     let mut existing_file_path = data_path.clone();
     existing_file_path.push("existing_among_us_dir.txt");
     let existing_found_folder = fs::read_to_string(existing_file_path.clone());
 
-    if existing_found_folder.is_ok() {
+    if let Ok(existing_folder) = existing_found_folder {
-        among_us_folder.push(existing_found_folder.unwrap());
+        among_us_folder.push(existing_folder);
     } else {
         let folder_opt = detect_among_us_folder();
         if folder_opt.is_some() {
             among_us_folder.push(folder_opt.unwrap());
         } else {
-            let path_rc = Rc::new(RefCell::new(String::from("")));
-            let data: AppData = AppData {
-                among_us_path: path_rc.clone(),
-            };
             let open_button = Button::new("Locate Among Us").fix_height(45.0).on_click(
                 move |ctx, _: &mut AppData, _| {
                     ctx.submit_command(
@@ -194,57 +180,51 @@ async fn main() {
                     );
                 },
             );
-            let flex: Flex<AppData> = Flex::column().with_flex_child(open_button, 1.0);
-            let open_dialog = WindowDesc::new(|| flex)
-                .title("Among Us Not Found!")
-                .window_size((400.0, 400.0));
-            AppLauncher::with_window(open_dialog)
-                .delegate(Delegate)
-                .launch(data)
-                .unwrap_or_default();
 
-            among_us_folder = path::PathBuf::from(Rc::try_unwrap(path_rc).unwrap().take());
+            // If we can't find Among Us, add the locate button.
+            // TODO: make this button then update the UI assuming it's valid
 
-            println!("{}", among_us_folder.to_str().unwrap());
+            root_column.add_flex_child(open_button, 1.0);
-
-            // win.modal_msg(&ui, "Find Among Us", "On the following Open File dialog, navigate to your Among Us folder and select Among Us.exe");
-            // let open_window = win.open_file(&ui);
-            // println!("{}", open_window.unwrap().to_str().unwrap());
-            // among_us_folder = open_window.unwrap().clone();
 
             // Pop the selected file off the end of the path
             // among_us_folder.pop();
         }
+
+        if among_us_folder.exists() {
             fs::write(existing_file_path, among_us_folder.to_str().unwrap()).unwrap();
         }
+    }
 
-    println!("Among Us Folder: {}", among_us_folder.to_str().unwrap());
+    if let Some(among_us_folder_str) = among_us_folder.to_str() {
+        if among_us_folder_str.len() > 0 {
+            println!("Among Us Folder: {}", among_us_folder_str);
+        } else {
+            println!("Among Us Folder not automatically determined");
+        }
+    }
 
-    let among_us_version =
+    if let Some(among_us_version) =
-        determine_among_us_version(String::from(among_us_folder.to_str().unwrap())).unwrap();
+        determine_among_us_version(String::from(among_us_folder.to_str().unwrap()))
+    {
+        println!("AmongUsVersion: {}", among_us_version);
         let ver_url: (String, String, bool) =
             determine_town_of_us_url(among_us_version.to_string().clone())
                 .await
                 .unwrap();
 
-    let version_smash = format!(
+        let version_smash = format!("{}-{}", among_us_version, ver_url.0.clone());
-        "{}-{}",
+        let new_installed_path: PathBuf = [installs_path.to_str().unwrap(), version_smash.as_str()]
-        among_us_version.to_string().clone(),
-        ver_url.0.clone()
-    );
-    let new_installed_path: path::PathBuf =
-        [installs_path.to_str().unwrap(), version_smash.as_str()]
             .iter()
             .collect();
 
-    if !path::Path::exists(&new_installed_path) {
+        if !Path::exists(&new_installed_path) {
-        println!("Copying Among Us to separate location...");
+            println!("Copying Among Us to cache location...");
             copy_folder_to_target(
                 among_us_folder.to_str().unwrap(),
                 installs_path.to_str().unwrap(),
             );
 
-        let among_us_path: path::PathBuf = [installs_path.to_str().unwrap(), "Among Us\\"]
+            let among_us_path: PathBuf = [installs_path.to_str().unwrap(), "Among Us\\"]
                 .iter()
                 .collect();
 
@@ -267,10 +247,10 @@ async fn main() {
 
             fs::rename(among_us_path, new_installed_path.clone()).unwrap();
             let mut download_path = data_path.clone();
-        let downloaded_filename = ver_url.1.rsplit("/").nth(0).unwrap();
+            let downloaded_filename = ver_url.1.rsplit('/').next().unwrap();
             download_path.push(downloaded_filename.clone());
 
-        if !path::Path::exists(&download_path) {
+            if !Path::exists(&download_path) {
                 // println!("{:?}", download_path);
                 println!("Downloading Town of Us... [{}]", ver_url.1.clone());
                 let zip = reqwest::get(ver_url.1.clone())
@@ -283,16 +263,16 @@ async fn main() {
             }
 
             let opened_zip = fs::File::open(download_path).unwrap();
-        println!("Extracting...");
+            println!("Extracting mod zip file...");
             let mut archive = zip::ZipArchive::new(opened_zip).unwrap();
             archive.extract(data_path.clone()).unwrap();
 
             let mut root_folder_path = String::new();
             for i in archive.file_names() {
-            root_folder_path = String::from(i.split("/").nth(0).unwrap());
+                root_folder_path = String::from(i.split('/').next().unwrap());
                 break;
             }
-        let extracted_path: path::PathBuf =
+            let extracted_path: PathBuf =
                 [data_path.to_str().unwrap(), root_folder_path.as_str(), "."]
                     .iter()
                     .collect();
@@ -307,24 +287,23 @@ async fn main() {
 
         // Find existing installs, make buttons for them
         let install_iter = fs::read_dir(installs_path.clone());
-    let mut root_column: druid::widget::Flex<u32> = druid::widget::Flex::column();
 
         if let Ok(iter) = install_iter {
-        let mut collection: Vec<Result<fs::DirEntry, std::io::Error>> = iter.collect();
+            let mut collection: Vec<Result<fs::DirEntry, io::Error>> = iter.collect();
             collection.reverse();
 
             // Iterate first to find labels:
 
-        let mut flexbox_array: Vec<druid::widget::Flex<u32>> = Vec::new();
+            let mut flexbox_array: Vec<druid::widget::Flex<AppData>> = Vec::new();
             let mut auv_array: Vec<String> = Vec::new();
 
             for i in &collection {
                 let existing_ver_smash = i.as_ref().unwrap().file_name();
-            let mut ver_smash_split = existing_ver_smash.to_str().unwrap().split("-");
+                let mut ver_smash_split = existing_ver_smash.to_str().unwrap().split('-');
                 let auv = ver_smash_split.next().unwrap();
                 if !auv_array.contains(&auv.to_string()) {
                     let label_text = format!("Among Us {}", auv);
-                let flex: druid::widget::Flex<u32> = druid::widget::Flex::column()
+                    let flex: druid::widget::Flex<AppData> = druid::widget::Flex::column()
                         .with_flex_child(
                             druid::widget::Label::new(label_text.as_str()).with_text_size(24.0),
                             1.0,
@@ -335,51 +314,68 @@ async fn main() {
                 }
             }
 
+            println!("Installs list:");
+
             for i in collection {
                 let existing_ver_smash = i.unwrap().file_name();
-            let mut ver_smash_split = existing_ver_smash.to_str().unwrap().split("-");
+                let mut ver_smash_split = existing_ver_smash.to_str().unwrap().split('-');
                 let auv = ver_smash_split.next().unwrap();
-            let button_string: String = format!("Town of Us {}", ver_smash_split.next().unwrap());
+                let button_string: String =
+                    format!("Town of Us {}", ver_smash_split.next().unwrap());
 
-            let mut index = 0;
+                for (index, j) in auv_array.iter().enumerate() {
-            for j in &auv_array {
                     if j == auv {
                         let mut clone = installs_path.clone();
                         clone.push(existing_ver_smash.clone());
 
+                        let mut button_row: Flex<AppData> = Flex::row();
+
                         let fybutton = druid::widget::Button::new(button_string.as_str())
                             .fix_height(45.0)
-                        .on_click(move |_, _: &mut u32, _| {
+                            .center()
+                            .on_click(move |_, _: &mut AppData, _| {
                                 attempt_run_among_us(&clone);
                             });
 
+                        button_row.add_flex_child(fybutton, 1.0);
+
+                        // TODO: Uncomment
+                        // let delete_button = druid::widget::Button::new("Delete")
+                        //     .fix_height(45.0)
+                        //     .on_click(move |_, _: &mut AppData, _| {});
+
+                        // button_row.add_flex_child(delete_button, 1.0);
+
                         flexbox_array
                             .get_mut(index)
                             .unwrap()
-                        .add_flex_child(fybutton, 1.0);
+                            .add_flex_child(button_row, 1.0);
 
-                    println!("{}", existing_ver_smash.clone().to_str().unwrap());
+                        println!("- {}", existing_ver_smash.clone().to_str().unwrap());
-                }
-                index += 1;
                     }
                 }
+            }
+
             for i in flexbox_array {
                 root_column.add_flex_child(i, 1.0);
             }
         }
+    }
 
     // println!("Checking for updater updates...");
     // let vals: (String, String) = version_check_thread_handle.join().unwrap();
 
+    // TODO: Auto launch latest sanctioned if the user has a setting like that
+    //       Auto launch latest experimental as well
+
     println!("Launching main window...");
 
     let main_window = WindowDesc::new(|| root_column)
         .title(title_string)
         .window_size((400.0, 400.0));
     let app_launcher = AppLauncher::with_window(main_window);
-    let external_handler = app_launcher.get_external_handle();
+    let _external_handler = app_launcher.get_external_handle();
-    app_launcher.launch(1).unwrap();
+    app_launcher.launch(app_data).unwrap();
-    // AppLauncher::with_window(main_window).launch(1).unwrap();
 
     // let mut install_folder_path = installs_path.clone();
     // install_folder_path.push(version_smash);
@@ -392,7 +388,7 @@ async fn main() {
     //     .iter()
     //     .collect();
 
-    // std::process::Command::new(executable_path.to_str().unwrap())
+    // process::Command::new(executable_path.to_str().unwrap())
     //     .spawn()
     //     .unwrap();
 }
@@ -416,23 +412,6 @@ async fn determine_town_of_us_url(among_us_version: String) -> Option<(String, S
         println!("Sanctioned version cannot be determined, installing experimental latest...");
         line = markdown.find("[Download]");
         line_offset = 15;
-        // println!("At this point, there are two options:");
-        // println!(" [1] Revert Among Us to public-previous in Steam THEN select this option.");
-        // println!(" [2] Attempt to use the latest version of Town of Us anyway");
-        // let mut input = String::new();
-        // io::stdin().read_line(&mut input).unwrap();
-        // match input.trim() {
-        //     "1" => {
-        //         println!("Re-attempting...");
-        //         return None;
-        //     }
-        //     "2" => {
-        //         println!("Continuing...");
-        //         line = markdown.find("[Download]");
-        //         line_offset = 15;
-        //     }
-        //     _ => return None,
-        // };
     }
     // 100% scientific "-15" here to get the correct version since we find to [Download] above which is after the version number for that line
     let splits = markdown.split_at(line.unwrap() - line_offset);
@@ -460,9 +439,7 @@ fn determine_among_us_version(folder_root: String) -> Option<AmongUsVersion> {
 
     let target_bytes: [u8; TARGET_BYTES_LEN] = [3, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0];
 
-    let file_bytes = fs::read(asset_file).unwrap();
+    if let Ok(file_bytes) = fs::read(asset_file) {
-    //println!("{:?}", file_bytes);
-
         let mut bytes_str = String::new();
         let mut target_head = 0;
         let mut file_index = 0;
@@ -483,30 +460,17 @@ fn determine_among_us_version(folder_root: String) -> Option<AmongUsVersion> {
         let offset: usize = usize::from(file_bytes[file_index]);
         file_index += 4;
 
-    // let mut offset = 10;
+        Some(AmongUsVersion::from(
-
-    // if file_bytes[file_index + 9] == 0 {
-    //     offset -= 1;
-    // }
-    // if file_bytes[file_index + 8] == 0 {
-    //     offset -= 1;
-    // }
-
-    // println!(
-    //     "|{}|",
-    //     str::from_utf8(file_bytes.get(file_index..file_index + offset).unwrap()).unwrap()
-    // );
-    let ver = AmongUsVersion::from(
             str::from_utf8(file_bytes.get(file_index..file_index + offset).unwrap()).unwrap(),
-    );
+        ))
-    println!("AmongUsVersion: {}", ver);
+    } else {
-    Some(ver)
+        None
-    // Some(String::from(
+    }
-    //     str::from_utf8(file_bytes.get(file_index..file_index + offset).unwrap()).unwrap(),
+
-    // ))
+    //println!("{:?}", file_bytes);
 }
 
-fn copy_folder_to_target<T: AsRef<path::Path>>(source: T, dest: T) {
+fn copy_folder_to_target<T: AsRef<Path>>(source: T, dest: T) {
     let mut copy_opts = dir::CopyOptions::new();
     copy_opts.overwrite = true;
     copy_opts.skip_exist = true;
@@ -516,7 +480,7 @@ fn copy_folder_to_target<T: AsRef<path::Path>>(source: T, dest: T) {
     copy_items(&from_paths, dest, &copy_opts).unwrap();
 }
 
-fn copy_folder_contents_to_target<T: AsRef<path::Path>>(source: T, dest: T) {
+fn copy_folder_contents_to_target<T: AsRef<Path>>(source: T, dest: T) {
     let mut copy_opts = dir::CopyOptions::new();
     copy_opts.overwrite = true;
     copy_opts.skip_exist = true;