dormedas/town-of-us-updater
1
1
Fork 0
Code Issues 8 Pull Requests Projects Releases 11 Wiki Activity

Merge branch 'feature-cleanup'

Browse Source
This commit is contained in:
Ian Mason
2022-08-31 12:53:29 -07:00
parent 84d206a87b e59c25af25
commit 81e8eaad0f
2 changed files with 254 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/among_us_version.rs Normal file
View File

@@ -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,
}
}
}

238
src/main.rs
View File

@@ -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 fs_extra::{copy_items, dir};
use regex::Regex; use regex::Regex;
// GUI stuff
use druid::{
commands, widget::*, AppDelegate, AppLauncher, Application, Data, DelegateCtx, Env,
FileDialogOptions, Handled, Target, WidgetExt, WindowDesc,
};
struct Delegate; struct Delegate;
#[derive(Data, Clone)] #[derive(Data, Clone)]
struct AppData { struct AppData {
pub among_us_path: Rc<RefCell<String>>, 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) { 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() .iter()
.collect(); .collect();
std::process::Command::new(executable_path.to_str().unwrap()) process::Command::new(executable_path.to_str().unwrap())
.spawn() .spawn()
.unwrap(); .unwrap();
} }
fn unmod_among_us_folder(folder_path: &Path) { fn unmod_among_us_folder(folder_path: &Path) {
println!("Unmodding Among Us...");
let doorstop_path: PathBuf = [folder_path.to_str().unwrap(), "doorstop_config.ini"] let doorstop_path: PathBuf = [folder_path.to_str().unwrap(), "doorstop_config.ini"]
.iter() .iter()
.collect(); .collect();
@@ -65,6 +47,7 @@ fn unmod_among_us_folder(folder_path: &Path) {
let winhttp_path: PathBuf = [folder_path.to_str().unwrap(), "winhttp.dll"] let winhttp_path: PathBuf = [folder_path.to_str().unwrap(), "winhttp.dll"]
.iter() .iter()
.collect(); .collect();
let bepinex_path: PathBuf = [folder_path.to_str().unwrap(), "BepInEx"].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(); let mono_path: PathBuf = [folder_path.to_str().unwrap(), "mono"].iter().collect();
fs::remove_file(doorstop_path).unwrap_or_default(); fs::remove_file(doorstop_path).unwrap_or_default();
@@ -144,6 +127,7 @@ impl AppDelegate<AppData> for Delegate {
println!("{}", buf.to_str().unwrap()); println!("{}", buf.to_str().unwrap());
println!("Handled!"); println!("Handled!");
Application::global().quit(); Application::global().quit();
return Handled::Yes; return Handled::Yes;
} }
Handled::No Handled::No
@@ -157,7 +141,6 @@ async fn main() {
println!("Updater Version: {}", version); println!("Updater Version: {}", version);
get_latest_updater_version().await.unwrap(); get_latest_updater_version().await.unwrap();
//let _version_check_thread_handle = thread::spawn(move || get_latest_updater_version());
// CREATE PROGRAM DIRECTORY // CREATE PROGRAM DIRECTORY
let mut data_path = dirs::data_dir().unwrap(); let mut data_path = dirs::data_dir().unwrap();
@@ -168,25 +151,28 @@ async fn main() {
installs_path.push("installs"); installs_path.push("installs");
fs::create_dir(installs_path.clone()).unwrap_or(()); 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 // 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(); let mut existing_file_path = data_path.clone();
existing_file_path.push("existing_among_us_dir.txt"); existing_file_path.push("existing_among_us_dir.txt");
let existing_found_folder = fs::read_to_string(existing_file_path.clone()); 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 { } else {
let folder_opt = detect_among_us_folder(); let folder_opt = detect_among_us_folder();
if folder_opt.is_some() { if folder_opt.is_some() {
among_us_folder.push(folder_opt.unwrap()); among_us_folder.push(folder_opt.unwrap());
} else { } 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( let open_button = Button::new("Locate Among Us").fix_height(45.0).on_click(
move |ctx, _: &mut AppData, _| { move |ctx, _: &mut AppData, _| {
ctx.submit_command( 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 // Pop the selected file off the end of the path
// among_us_folder.pop(); // among_us_folder.pop();
} }
if among_us_folder.exists() {
fs::write(existing_file_path, among_us_folder.to_str().unwrap()).unwrap(); 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) = let ver_url: (String, String, bool) =
determine_town_of_us_url(among_us_version.to_string().clone()) determine_town_of_us_url(among_us_version.to_string().clone())
.await .await
.unwrap(); .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() .iter()
.collect(); .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( copy_folder_to_target(
among_us_folder.to_str().unwrap(), among_us_folder.to_str().unwrap(),
installs_path.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() .iter()
.collect(); .collect();
@@ -267,10 +247,10 @@ async fn main() {
fs::rename(among_us_path, new_installed_path.clone()).unwrap(); fs::rename(among_us_path, new_installed_path.clone()).unwrap();
let mut download_path = data_path.clone(); 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()); download_path.push(downloaded_filename.clone());
if !path::Path::exists(&download_path) { if !Path::exists(&download_path) {
// println!("{:?}", download_path); // println!("{:?}", download_path);
println!("Downloading Town of Us... [{}]", ver_url.1.clone()); println!("Downloading Town of Us... [{}]", ver_url.1.clone());
let zip = reqwest::get(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(); 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(); let mut archive = zip::ZipArchive::new(opened_zip).unwrap();
archive.extract(data_path.clone()).unwrap(); archive.extract(data_path.clone()).unwrap();
let mut root_folder_path = String::new(); let mut root_folder_path = String::new();
for i in archive.file_names() { 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; break;
} }
let extracted_path: path::PathBuf = let extracted_path: PathBuf =
[data_path.to_str().unwrap(), root_folder_path.as_str(), "."] [data_path.to_str().unwrap(), root_folder_path.as_str(), "."]
.iter() .iter()
.collect(); .collect();
@@ -307,24 +287,23 @@ async fn main() {
// Find existing installs, make buttons for them // Find existing installs, make buttons for them
let install_iter = fs::read_dir(installs_path.clone()); 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 { 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(); collection.reverse();
// Iterate first to find labels: // 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(); let mut auv_array: Vec<String> = Vec::new();
for i in &collection { for i in &collection {
let existing_ver_smash = i.as_ref().unwrap().file_name(); 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(); let auv = ver_smash_split.next().unwrap();
if !auv_array.contains(&auv.to_string()) { if !auv_array.contains(&auv.to_string()) {
let label_text = format!("Among Us {}", auv); 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( .with_flex_child(
druid::widget::Label::new(label_text.as_str()).with_text_size(24.0), druid::widget::Label::new(label_text.as_str()).with_text_size(24.0),
1.0, 1.0,
@@ -335,42 +314,60 @@ async fn main() {
} }
} }
println!("Installs list:");
for i in collection { for i in collection {
let existing_ver_smash = i.unwrap().file_name(); 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 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 { if j == auv {
let mut clone = installs_path.clone(); let mut clone = installs_path.clone();
clone.push(existing_ver_smash.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()) let fybutton = druid::widget::Button::new(button_string.as_str())
.fix_height(45.0) .fix_height(45.0)
.on_click(move |_, _: &mut u32, _| { .center()
.on_click(move |_, _: &mut AppData, _| {
attempt_run_among_us(&clone); 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 flexbox_array
.get_mut(index) .get_mut(index)
.unwrap() .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 { for i in flexbox_array {
root_column.add_flex_child(i, 1.0); root_column.add_flex_child(i, 1.0);
} }
} }
}
// println!("Checking for updater updates..."); // println!("Checking for updater updates...");
// let vals: (String, String) = version_check_thread_handle.join().unwrap(); // 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..."); println!("Launching main window...");
let main_window = WindowDesc::new(|| root_column) let main_window = WindowDesc::new(|| root_column)
@@ -378,8 +375,7 @@ async fn main() {
.window_size((400.0, 400.0)); .window_size((400.0, 400.0));
let app_launcher = AppLauncher::with_window(main_window); 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(); // let mut install_folder_path = installs_path.clone();
// install_folder_path.push(version_smash); // install_folder_path.push(version_smash);
@@ -392,7 +388,7 @@ async fn main() {
// .iter() // .iter()
// .collect(); // .collect();
// std::process::Command::new(executable_path.to_str().unwrap()) // process::Command::new(executable_path.to_str().unwrap())
// .spawn() // .spawn()
// .unwrap(); // .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..."); println!("Sanctioned version cannot be determined, installing experimental latest...");
line = markdown.find("[Download]"); line = markdown.find("[Download]");
line_offset = 15; 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 // 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); 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 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 bytes_str = String::new();
let mut target_head = 0; let mut target_head = 0;
let mut file_index = 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]); let offset: usize = usize::from(file_bytes[file_index]);
file_index += 4; 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(), 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(),
// ))
} }
fn copy_folder_to_target<T: AsRef<path::Path>>(source: T, dest: T) { //println!("{:?}", file_bytes);
}
fn copy_folder_to_target<T: AsRef<Path>>(source: T, dest: T) {
let mut copy_opts = dir::CopyOptions::new(); let mut copy_opts = dir::CopyOptions::new();
copy_opts.overwrite = true; copy_opts.overwrite = true;
copy_opts.skip_exist = 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(); 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(); let mut copy_opts = dir::CopyOptions::new();
copy_opts.overwrite = true; copy_opts.overwrite = true;
copy_opts.skip_exist = true; copy_opts.skip_exist = true;