v0.6.10

Bump serde from 1.0.196 to 1.0.197

.github/workflows/release.yml

@@ -21,12 +21,14 @@ jobs:
         include:
           - target: x86_64-unknown-linux-gnu
             os: ubuntu-20.04
-          - target: i686-unknown-linux-gnu
+          - target: aarch64-unknown-linux-gnu
             os: ubuntu-20.04
           - target: x86_64-pc-windows-msvc
             os: windows-latest
           - target: i686-pc-windows-msvc
             os: windows-latest
+          - target: x86_64-apple-darwin
+            os: macos-latest
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4

Cargo.toml

@@ -1,33 +1,33 @@
 [package]
 name = "alterware-launcher"
-version = "0.5.4"
+version = "0.6.10"
 edition = "2021"
 build = "res/build.rs"
 
 [profile.release]
 opt-level = "s"
 
-# Symbols are a nice thing
-debug = true
-
 panic = "abort"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-http_req = { version = "0.10.0", default-features = false, features = [
-    "rust-tls",
-] }
 sha1_smol = "1.0.0"
-serde = { version = "1.0.189", features = ["derive"] }
+serde = { version = "1.0.197", features = ["derive"] }
-serde_json = "1.0.107"
+serde_json = "1.0.114"
 rand = "0.8.5"
-semver = "1.0.20"
+semver = "1.0.22"
-zip = "0.6.6"
+colored = "2.1.0"
-colored = "2.0.4"
+reqwest = { version = "0.11.24", features = ["stream"] }
+futures-util = "0.3.30"
+indicatif = "0.17.8"
+tokio = {version="1.36.0", features = ["rt-multi-thread", "macros"]}
+
+[target.'cfg(unix)'.dependencies]
+openssl = { version = "0.10.64", default-features = false, features = ["vendored"] }
 
 [target.'cfg(windows)'.dependencies]
-steamlocate = "2.0.0-alpha.0"
+steamlocate = "=2.0.0-beta.2"
 mslnk = "0.1.8"
 self-replace = "1.3.7"
 

README.md

@@ -4,13 +4,16 @@
 
 ##### IW4x | IW4-SP | IW5-Mod | IW6-Mod | S1-Mod
 
+![GitHub tag (with filter)](https://img.shields.io/github/v/tag/mxve/alterware-launcher?filter=!v*-pre&style=flat-square&label=Latest%20release&labelColor=F3F8FF&color=E26EE5) ![GitHub (Pre-)Release Date](https://img.shields.io/github/release-date-pre/mxve/alterware-launcher?style=flat-square&label=Release%20date&labelColor=F3F8FF&color=E26EE5) ![GitHub all releases](https://img.shields.io/github/downloads/mxve/alterware-launcher/total?style=flat-square&label=Total%20downloads&labelColor=F3F8FF&color=E26EE5)
+
 ---
 
-#### Installation
+## Installation
 
-1. Download the [latest alterware-launcher.exe](https://github.com/mxve/alterware-launcher/releases/latest/download/alterware-launcher.exe)
+1. Download the game from [Steam](https://store.steampowered.com/)
-2. Place alterware-launcher.exe in the game directory
+2. Download the [latest alterware-launcher.exe](https://github.com/mxve/alterware-launcher/releases/latest/download/alterware-launcher.exe)
-3. Run alterware-launcher.exe, after updating the game will launch automatically
+3. Place alterware-launcher.exe in the game directory
+4. Run alterware-launcher.exe, after updating the game will launch automatically
 
 ---
 
@@ -35,6 +38,8 @@
     - See [client-args.md](client-args.md)
 - ```--version```, ```-v```
   - Print the launcher version
+- ```--ignore-required-files```
+  - Install client even if required files are missing
 
 Example: ```alterware-launcher.exe iw4x --bonus -u --path "C:\Games\IW4x" --pass "-console"```
 
@@ -63,6 +68,9 @@ alterware-launcher.json
 - ```args```
   - See --pass
   - Default: ""
+- ```use_https```
+  - Use HTTPS for downloads
+  - Default: false
 
 ---
 
@@ -82,13 +90,6 @@ Visit the [AlterWare Forum](https://forum.alterware.dev/) or [Discord](https://d
 ---
 
 ### Note for server owners:
-When the launcher updates itself it needs to be restarted. It will return exit code 201 in this case.
+When the launcher updates itself __on Windows__ it will restart by spawning a new console. If you are automating this process, you should probably use ```--skip-launcher-update``` and download the latest launcher yourself from [here](https://github.com/mxve/alterware-launcher/releases/latest/download/alterware-launcher.exe).
 
-```
+The linux build does __not__ update itself.
-@echo off
-:loop
-start /wait alterware-launcher.exe --update
-if %errorlevel% equ 201 (
-    goto loop
-)
-```

src/config.rs

@@ -36,6 +36,17 @@ pub fn save_value(config_path: PathBuf, key: &str, value: bool) {
         "download_bonus_content" => config.download_bonus_content = value,
         "ask_bonus_content" => config.ask_bonus_content = value,
         "force_update" => config.force_update = value,
+        "use_https" => config.use_https = value,
+        _ => (),
+    }
+    save(config_path, config);
+}
+
+pub fn save_value_s(config_path: PathBuf, key: &str, value: String) {
+    let mut config = load(config_path.clone());
+    match key {
+        "args" => config.args = value.to_string(),
+        "engine" => config.engine = value.to_string(),
         _ => (),
     }
     save(config_path, config);

src/github.rs

@@ -1,19 +1,21 @@
 use semver::Version;
 
-pub fn latest_tag(owner: &str, repo: &str) -> String {
+pub async fn latest_tag(owner: &str, repo: &str) -> String {
-    let github_body = crate::http::get_body_string(
+    let github_body = crate::http_async::get_body_string(
         format!(
             "https://api.github.com/repos/{}/{}/releases/latest",
             owner, repo
         )
         .as_str(),
-    );
+    )
+    .await
+    .unwrap();
     let github_json: serde_json::Value = serde_json::from_str(&github_body).unwrap();
     github_json["tag_name"].to_string().replace('"', "")
 }
 
-pub fn latest_version(owner: &str, repo: &str) -> Version {
+pub async fn latest_version(owner: &str, repo: &str) -> Version {
-    let tag = latest_tag(owner, repo).replace('v', "");
+    let tag = latest_tag(owner, repo).await.replace('v', "");
     Version::parse(&tag).unwrap()
 }
 

src/global.rs

@@ -1,4 +1,4 @@
-pub const MASTER: &str = "https://master.alterware.dev";
+pub const MASTER: &str = "cdn.alterware.ovh";
 pub const GH_OWNER: &str = "mxve";
 pub const GH_REPO: &str = "alterware-launcher";
 pub const GH_IW4X_OWNER: &str = "iw4x";

src/http.rs

@@ -1,84 +0,0 @@
-use crate::global;
-use crate::misc;
-use std::{fs, io::Write, path::Path, str};
-
-pub fn get_body(url: &str) -> Vec<u8> {
-    let mut res: Vec<u8> = Vec::new();
-
-    match http_req::request::Request::new(&url.try_into().unwrap())
-        .header(
-            "User-Agent",
-            &format!(
-                "AlterWare Launcher | github.com/{}/{}",
-                global::GH_OWNER,
-                global::GH_REPO
-            ),
-        )
-        .send(&mut res)
-    {
-        Ok(req) => {
-            if req.status_code() == http_req::response::StatusCode::new(302)
-                || req.status_code() == http_req::response::StatusCode::new(301)
-            {
-                let location = req.headers().get("Location").unwrap().as_str();
-                return get_body(location);
-            }
-
-            if req.status_code() != http_req::response::StatusCode::new(200) {
-                misc::fatal_error(&format!(
-                    "Could not get body from {}, got {}",
-                    url,
-                    req.status_code()
-                ));
-            }
-        }
-        Err(e) => {
-            misc::fatal_error(&format!("Could not get body from {}, got:\n{}", url, e));
-        }
-    }
-
-    res
-}
-
-pub fn get_body_string(url: &str) -> String {
-    String::from_utf8(get_body(url)).unwrap()
-}
-
-pub fn download_file(url: &str, file_path: &Path) {
-    let body = get_body(url);
-
-    match fs::File::create(file_path) {
-        Ok(mut file) => match file.write_all(&body) {
-            Ok(_) => (),
-            Err(e) => {
-                misc::fatal_error(&format!(
-                    "Could not write to file {}, got:\n{}",
-                    file_path.to_str().unwrap(),
-                    e
-                ));
-            }
-        },
-        Err(e) => {
-            match e.kind() {
-                std::io::ErrorKind::NotFound => {
-                    fs::create_dir_all(file_path.parent().unwrap()).unwrap();
-                    return download_file(url, file_path);
-                }
-                std::io::ErrorKind::PermissionDenied => {
-                    misc::fatal_error(&format!(
-                        "Permission to {} denied.\n  Please try:\n    1. Running the launcher as administrator.\n    2. Manually deleting the last downloaded file.\n    3. If your game is in the program files directory try moving it to another location.\n    4. Create an exception/exclusion in your Anti-Virus Software for either the last downloaded file or the entire game directory.\n\n\n{}",
-                        file_path.to_str().unwrap(),
-                        e
-                    ));
-                }
-                _ => (),
-            }
-
-            misc::fatal_error(&format!(
-                "Could not create file {}, got:\n{}",
-                file_path.to_str().unwrap(),
-                e
-            ));
-        }
-    }
-}

src/http_async.rs

@@ -0,0 +1,127 @@
+use std::cmp::min;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+use colored::*;
+use futures_util::StreamExt;
+use indicatif::ProgressBar;
+use reqwest::Client;
+
+use crate::misc;
+
+pub async fn download_file_progress(
+    client: &Client,
+    pb: &ProgressBar,
+    url: &str,
+    path: &PathBuf,
+    size: u64,
+) -> Result<(), String> {
+    let res = client
+        .get(url)
+        .header(
+            "User-Agent",
+            &format!(
+                "AlterWare Launcher | github.com/{}/{}",
+                crate::global::GH_OWNER,
+                crate::global::GH_REPO
+            ),
+        )
+        .send()
+        .await
+        .or(Err(format!("Failed to GET from '{}'", &url)))?;
+    // Fix for CF shenanigans
+    let total_size = res.content_length().unwrap_or(size);
+    pb.set_length(total_size);
+    pb.println(format!(
+        "[{}] {} ({})",
+        "Downloading".bright_yellow(),
+        misc::cute_path(path),
+        misc::human_readable_bytes(total_size)
+    ));
+    pb.set_message(path.file_name().unwrap().to_str().unwrap().to_string());
+
+    let mut file =
+        File::create(path).or(Err(format!("Failed to create file '{}'", path.display())))?;
+    let mut downloaded: u64 = 0;
+    let mut stream = res.bytes_stream();
+
+    while let Some(item) = stream.next().await {
+        let chunk = item.or(Err("Error while downloading file"))?;
+        file.write_all(&chunk)
+            .or(Err("Error while writing to file"))?;
+        let new = min(downloaded + (chunk.len() as u64), total_size);
+        downloaded = new;
+        pb.set_position(new);
+    }
+
+    pb.set_message(String::default());
+    Ok(())
+}
+
+pub async fn download_file(url: &str, path: &PathBuf) -> Result<(), String> {
+    let client = Client::new();
+    match client
+        .get(url)
+        .header(
+            "User-Agent",
+            &format!(
+                "AlterWare Launcher | github.com/{}/{}",
+                crate::global::GH_OWNER,
+                crate::global::GH_REPO
+            ),
+        )
+        .send()
+        .await
+    {
+        Ok(res) => {
+            let body = res.bytes().await.or(Err("Failed to download file"))?;
+            let mut file = File::create(path).or(Err("Failed to create file"))?;
+            file.write_all(&body).or(Err("Failed to write to file"))?;
+            Ok(())
+        }
+        Err(e) => {
+            misc::fatal_error(&format!(
+                "Could not download file from {}, got:\n{}",
+                url, e
+            ));
+            Err("Could not download file".to_string())
+        }
+    }
+}
+
+pub async fn get_body(url: &str) -> Result<Vec<u8>, String> {
+    let client = Client::new();
+    match client
+        .get(url)
+        .header(
+            "User-Agent",
+            &format!(
+                "AlterWare Launcher | github.com/{}/{}",
+                crate::global::GH_OWNER,
+                crate::global::GH_REPO
+            ),
+        )
+        .send()
+        .await
+    {
+        Ok(res) => {
+            println!(
+                "[DEBUG] {} {}",
+                res.status().to_string().bright_yellow(),
+                url.bright_yellow()
+            );
+            let body = res.bytes().await.or(Err("Failed to get body"))?;
+            Ok(body.to_vec())
+        }
+        Err(e) => {
+            misc::fatal_error(&format!("Could not get body from {}, got:\n{}", url, e));
+            Err("Could not get body".to_string())
+        }
+    }
+}
+
+pub async fn get_body_string(url: &str) -> Result<String, String> {
+    let body = get_body(url).await?;
+    Ok(String::from_utf8(body).unwrap())
+}

src/io.rs

@@ -1,22 +0,0 @@
-use std::{fs, path::Path};
-
-pub fn unzip(zip_path: &Path, out_path: &Path) {
-    let mut archive = zip::ZipArchive::new(fs::File::open(zip_path).unwrap()).unwrap();
-    for i in 0..archive.len() {
-        let mut file = archive.by_index(i).unwrap();
-        let outpath = out_path.join(file.name());
-
-        if (*file.name()).ends_with('/') {
-            fs::create_dir_all(outpath).unwrap();
-        } else {
-            println!("Unpacking {}", file.name());
-            if let Some(p) = outpath.parent() {
-                if !p.exists() {
-                    fs::create_dir_all(p).unwrap();
-                }
-            }
-            let mut outfile = fs::File::create(&outpath).unwrap();
-            std::io::copy(&mut file, &mut outfile).unwrap();
-        }
-    }
-}

src/iw4x.rs

@@ -1,6 +1,6 @@
 use crate::github;
 use crate::global::*;
-use crate::http;
+use crate::http_async;
 use crate::misc;
 
 use colored::*;
@@ -14,29 +14,39 @@ pub fn local_revision(dir: &Path) -> u16 {
     }
 }
 
-pub fn remote_revision() -> u16 {
+pub async fn remote_revision() -> u16 {
-    misc::rev_to_int(&github::latest_tag(GH_IW4X_OWNER, GH_IW4X_REPO))
+    misc::rev_to_int(&github::latest_tag(GH_IW4X_OWNER, GH_IW4X_REPO).await)
 }
 
-pub fn update(dir: &Path) {
+pub async fn update(dir: &Path) {
-    let remote = remote_revision();
+    let remote = remote_revision().await;
     let local = local_revision(dir);
 
     if remote <= local && dir.join("iw4x.dll").exists() {
+        println!(
+            "[{}]        No files to download for IW4x",
+            "Info".bright_magenta(),
+        );
         return;
     }
 
+    println!(
+        "[{}]        Downloading outdated or missing files for IW4x",
+        "Info".bright_magenta()
+    );
     println!(
         "[{}] {}",
         "Downloading".bright_yellow(),
-        dir.join("iw4x.dll").display()
+        misc::cute_path(&dir.join("iw4x.dll"))
     );
-    http::download_file(
+    http_async::download_file(
         &format!(
             "{}/download/iw4x.dll",
             github::latest_release_url(GH_IW4X_OWNER, GH_IW4X_REPO)
         ),
         &dir.join("iw4x.dll"),
-    );
+    )
+    .await
+    .unwrap();
     fs::write(dir.join(".iw4xrevision"), format!("r{}", remote)).unwrap();
 }

src/main.rs

@@ -1,7 +1,7 @@
 mod config;
 mod github;
 mod global;
-mod http;
+mod http_async;
 mod iw4x;
 mod misc;
 mod self_update;
@@ -11,26 +11,34 @@ use global::*;
 use structs::*;
 
 use colored::*;
+use indicatif::ProgressBar;
 #[cfg(windows)]
 use mslnk::ShellLink;
-use std::{borrow::Cow, collections::HashMap, fs, path::Path, path::PathBuf};
+use std::{borrow::Cow, collections::HashMap, env, fs, path::Path, path::PathBuf};
 #[cfg(windows)]
 use steamlocate::SteamDir;
 
 #[cfg(windows)]
 fn get_installed_games(games: &Vec<Game>) -> Vec<(u32, PathBuf)> {
     let mut installed_games = Vec::new();
-    let mut steamdir = match SteamDir::locate() {
+    let steamdir_result = SteamDir::locate();
-        Some(steamdir) => steamdir,
+
-        None => {
+    let steamdir = match steamdir_result {
-            println!("{}", "Steam not found!".yellow());
+        Ok(steamdir) => steamdir,
+        Err(error) => {
+            println!("Error locating Steam: {}", error);
             return installed_games;
         }
     };
 
     for game in games {
-        if let Some(app) = steamdir.app(&game.app_id) {
+        if let Ok(Some((app, library))) = steamdir.find_app(game.app_id) {
-            installed_games.push((game.app_id, PathBuf::from(&app.path)));
+            let game_path = library
+                .path()
+                .join("steamapps")
+                .join("common")
+                .join(&app.install_dir);
+            installed_games.push((game.app_id, game_path));
         }
     }
 
@@ -75,10 +83,7 @@ fn setup_desktop_links(path: &Path, game: &Game) {
     let input = misc::stdin().to_ascii_lowercase();
 
     if input == "y" || input.is_empty() {
-        let desktop = PathBuf::from(&format!(
+        let desktop = PathBuf::from(&format!("{}\\Desktop", env::var("USERPROFILE").unwrap()));
-            "{}\\Desktop",
-            std::env::var("USERPROFILE").unwrap()
-        ));
 
         for c in game.client.iter() {
             create_shortcut(
@@ -94,14 +99,14 @@ fn setup_desktop_links(path: &Path, game: &Game) {
 }
 
 #[cfg(windows)]
-fn auto_install(path: &Path, game: &Game) {
+async fn auto_install(path: &Path, game: &Game<'_>, master_url: &String) {
     setup_client_links(game, path);
     setup_desktop_links(path, game);
-    update(game, path, false, false);
+    update(game, path, false, false, None, master_url, None).await;
 }
 
 #[cfg(windows)]
-fn windows_launcher_install(games: &Vec<Game>) {
+async fn windows_launcher_install(games: &Vec<Game<'_>>, master_url: &String) {
     println!(
         "{}",
         "No game specified/found. Checking for installed Steam games..".yellow()
@@ -109,13 +114,13 @@ fn windows_launcher_install(games: &Vec<Game>) {
     let installed_games = get_installed_games(games);
 
     if !installed_games.is_empty() {
-        let current_dir = std::env::current_dir().unwrap();
+        let current_dir = env::current_dir().unwrap();
         for (id, path) in installed_games.iter() {
             if current_dir.starts_with(path) {
                 println!("Found game in current directory.");
                 println!("Installing AlterWare client for {}.", id);
                 let game = games.iter().find(|&g| g.app_id == *id).unwrap();
-                auto_install(path, game);
+                auto_install(path, game, master_url).await;
                 println!("Installation complete. Please run the launcher again or use a shortcut to launch the game.");
                 std::io::stdin().read_line(&mut String::new()).unwrap();
                 std::process::exit(0);
@@ -128,25 +133,21 @@ fn windows_launcher_install(games: &Vec<Game>) {
             println!("{}: {}", id, path.display());
         }
 
-        println!("Enter the ID of the game you want to install the AlterWare client for, enter 0 for manual selection:");
+        println!("Enter the ID of the game you want to install the AlterWare client for:");
         let input: u32 = misc::stdin().parse().unwrap();
 
-        if input == 0 {
-            return manual_install(games);
-        }
-
         for (id, path) in installed_games.iter() {
             if *id == input {
                 let game = games.iter().find(|&g| g.app_id == input).unwrap();
 
-                let launcher_path = std::env::current_exe().unwrap();
+                let launcher_path = env::current_exe().unwrap();
                 let target_path = path.join("alterware-launcher.exe");
 
                 if launcher_path != target_path {
                     fs::copy(launcher_path, target_path).unwrap();
                     println!("Launcher copied to {}", path.display());
                 }
-                auto_install(path, game);
+                auto_install(path, game, master_url).await;
                 println!("Installation complete. Please run the launcher again or use a shortcut to launch the game.");
                 std::io::stdin().read_line(&mut String::new()).unwrap();
                 break;
@@ -154,32 +155,36 @@ fn windows_launcher_install(games: &Vec<Game>) {
         }
         std::process::exit(0);
     } else {
-        manual_install(games);
-    }
-}
-
-fn prompt_client_selection(games: &[Game]) -> String {
         println!(
-        "Couldn't detect any games, please select a client to install in the current directory:"
+            "No installed games found. Make sure to place the launcher in the game directory."
         );
-    for (i, g) in games.iter().enumerate() {
-        for c in g.client.iter() {
-            println!("{}: {}", i, c);
-        }
-    }
-    let input: usize = misc::stdin().parse().unwrap();
-    String::from(games[input].client[0])
-}
-
-fn manual_install(games: &[Game]) {
-    let selection = prompt_client_selection(games);
-    let game = games.iter().find(|&g| g.client[0] == selection).unwrap();
-    update(game, &std::env::current_dir().unwrap(), false, false);
-    println!("Installation complete. Please run the launcher again or use a shortcut to launch the game.");
         std::io::stdin().read_line(&mut String::new()).unwrap();
         std::process::exit(0);
+    }
 }
 
+// fn prompt_client_selection(games: &[Game]) -> String {
+//     println!(
+//         "Couldn't detect any games, please select a client to install in the current directory:"
+//     );
+//     for (i, g) in games.iter().enumerate() {
+//         for c in g.client.iter() {
+//             println!("{}: {}", i, c);
+//         }
+//     }
+//     let input: usize = misc::stdin().parse().unwrap();
+//     String::from(games[input].client[0])
+// }
+
+// async fn manual_install(games: &[Game<'_>]) {
+//     let selection = prompt_client_selection(games);
+//     let game = games.iter().find(|&g| g.client[0] == selection).unwrap();
+//     update(game, &env::current_dir().unwrap(), false, false).await;
+//     println!("Installation complete. Please run the launcher again or use a shortcut to launch the game.");
+//     std::io::stdin().read_line(&mut String::new()).unwrap();
+//     std::process::exit(0);
+// }
+
 fn total_download_size(cdn_info: &Vec<CdnFile>, remote_dir: &str) -> u64 {
     let remote_dir = format!("{}/", remote_dir);
     let mut size: u64 = 0;
@@ -192,12 +197,17 @@ fn total_download_size(cdn_info: &Vec<CdnFile>, remote_dir: &str) -> u64 {
     size
 }
 
-fn update_dir(
+async fn update_dir(
     cdn_info: &Vec<CdnFile>,
     remote_dir: &str,
     dir: &Path,
     hashes: &mut HashMap<String, String>,
+    pb: &ProgressBar,
+    skip_iw4x_sp: bool,
+    master_url: &String,
 ) {
+    misc::pb_style_download(pb, false);
+
     let remote_dir_pre = format!("{}/", remote_dir);
 
     let mut files_to_download: Vec<CdnFile> = vec![];
@@ -206,6 +216,9 @@ fn update_dir(
         if !file.name.starts_with(&remote_dir_pre) || file.name == "iw4/iw4x.dll" {
             continue;
         }
+        if skip_iw4x_sp && file.name == "iw4/iw4x-sp.exe" {
+            continue;
+        }
 
         let sha1_remote = file.hash.to_lowercase();
         let file_name = &file.name.replace(remote_dir_pre.as_str(), "");
@@ -220,7 +233,12 @@ fn update_dir(
             if sha1_local != sha1_remote {
                 files_to_download.push(file.clone());
             } else {
-                println!("[{}]     {}", "Checked".bright_blue(), file_path.display());
+                pb.println(format!(
+                    "[{}]     {}",
+                    "Checked".bright_blue(),
+                    misc::cute_path(&file_path)
+                ));
+                hashes.insert(file_name.to_owned(), file.hash.to_lowercase());
             }
         } else {
             files_to_download.push(file.clone());
@@ -228,43 +246,69 @@ fn update_dir(
     }
 
     if files_to_download.is_empty() {
-        println!(
+        pb.println(format!(
             "[{}]        No files to download for {}",
             "Info".bright_magenta(),
             remote_dir
-        );
+        ));
         return;
     }
-    println!(
+    pb.println(format!(
         "[{}]        Downloading outdated or missing files for {}, {}",
         "Info".bright_magenta(),
         remote_dir,
         misc::human_readable_bytes(total_download_size(&files_to_download, remote_dir))
-    );
+    ));
+
+    misc::pb_style_download(pb, true);
+    let client = reqwest::Client::new();
     for file in files_to_download {
         let file_name = &file.name.replace(&remote_dir_pre, "");
         let file_path = dir.join(file_name);
-        println!(
-            "[{}] {} ({})",
-            "Downloading".bright_yellow(),
-            file_path.display(),
-            misc::human_readable_bytes(file.size as u64)
-        );
         if let Some(parent) = file_path.parent() {
             if !parent.exists() {
                 fs::create_dir_all(parent).unwrap();
             }
         }
-        http::download_file(&format!("{}/{}", MASTER, file.name), &file_path);
+        http_async::download_file_progress(
+            &client,
+            pb,
+            &format!("{}/{}", master_url, file.name),
+            &file_path,
+            file.size as u64,
+        )
+        .await
+        .unwrap();
         hashes.insert(file_name.to_owned(), file.hash.to_lowercase());
     }
+    misc::pb_style_download(pb, false);
 }
 
-fn update(game: &Game, dir: &Path, bonus_content: bool, force: bool) {
+async fn update(
-    let cdn_info: Vec<CdnFile> = serde_json::from_str(&http::get_body_string(
+    game: &Game<'_>,
-        format!("{}/files.json", MASTER).as_str(),
+    dir: &Path,
-    ))
+    bonus_content: bool,
+    force: bool,
+    skip_iw4x_sp: Option<bool>,
+    master_url: &String,
+    ignore_required_files: Option<bool>,
+) {
+    let skip_iw4x_sp = skip_iw4x_sp.unwrap_or(false);
+    let ignore_required_files = ignore_required_files.unwrap_or(false);
+
+    let res = http_async::get_body_string(format!("{}/files.json", master_url).as_str())
+        .await
         .unwrap();
+    let cdn_info: Vec<CdnFile> = serde_json::from_str(&res).unwrap();
+
+    if !ignore_required_files && !game.required_files_exist(dir) {
+        println!(
+            "{}\nVerify game file integrity on Steam or reinstall the game.",
+            "Critical game files missing.".bright_red()
+        );
+        std::io::stdin().read_line(&mut String::new()).unwrap();
+        std::process::exit(0);
+    }
 
     let mut hashes = HashMap::new();
     let hash_file = dir.join(".sha-sums");
@@ -278,15 +322,124 @@ fn update(game: &Game, dir: &Path, bonus_content: bool, force: bool) {
         }
     }
 
-    update_dir(&cdn_info, game.engine, dir, &mut hashes);
-
     if game.engine == "iw4" {
-        iw4x::update(dir);
+        iw4x::update(dir).await;
+
+        let iw4x_dirs = vec!["iw4x", "zone/patch"];
+        for d in &iw4x_dirs {
+            if let Ok(dir_iter) = dir.join(d).read_dir() {
+                'outer: for file in dir_iter.filter_map(|entry| entry.ok()) {
+                    let file_path = file.path();
+
+                    if file_path.is_dir() {
+                        continue;
                     }
 
+                    let file_path_rel = match file_path.strip_prefix(dir) {
+                        Ok(rel) => rel.to_path_buf(),
+                        Err(_) => continue,
+                    };
+
+                    if iw4x_dirs
+                        .iter()
+                        .any(|prefix| file_path_rel.starts_with(Path::new(prefix)))
+                    {
+                        if !cdn_info
+                            .iter()
+                            .any(|cdn_file| cdn_file.name.starts_with("iw4"))
+                        {
+                            continue;
+                        }
+
+                        let should_continue = cdn_info.iter().any(|cdn_file| {
+                            let path_rem = Path::new(&cdn_file.name)
+                                .strip_prefix(Path::new("iw4"))
+                                .unwrap_or_else(|_| Path::new(&cdn_file.name));
+                            path_rem == file_path_rel
+                        });
+
+                        if should_continue {
+                            continue 'outer;
+                        }
+
+                        println!(
+                            "[{}]     {}",
+                            "Removed".bright_red(),
+                            misc::cute_path(&file_path)
+                        );
+
+                        if fs::remove_file(&file_path).is_err() {
+                            println!(
+                                "[{}]      Couldn't delete {}",
+                                "Error".bright_red(),
+                                misc::cute_path(&file_path)
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let pb = ProgressBar::new(0);
+    update_dir(
+        &cdn_info,
+        game.engine,
+        dir,
+        &mut hashes,
+        &pb,
+        skip_iw4x_sp,
+        master_url,
+    )
+    .await;
+
     if bonus_content && !game.bonus.is_empty() {
         for bonus in game.bonus.iter() {
-            update_dir(&cdn_info, bonus, dir, &mut hashes);
+            update_dir(
+                &cdn_info,
+                bonus,
+                dir,
+                &mut hashes,
+                &pb,
+                skip_iw4x_sp,
+                master_url,
+            )
+            .await;
+        }
+    }
+
+    pb.finish();
+
+    for f in game.delete.iter() {
+        let file_path = dir.join(f);
+        if file_path.is_file() {
+            if fs::remove_file(&file_path).is_err() {
+                println!(
+                    "[{}]      Couldn't delete {}",
+                    "Error".bright_red(),
+                    misc::cute_path(&file_path)
+                );
+            } else {
+                println!(
+                    "[{}]     {}",
+                    "Removed".bright_red(),
+                    misc::cute_path(&file_path)
+                );
+            }
+        } else if file_path.is_dir() {
+            if fs::remove_dir_all(&file_path).is_err() {
+                println!(
+                    "[{}]      Couldn't delete {}",
+                    "Error".bright_red(),
+                    misc::cute_path(&file_path)
+                );
+            } else {
+                println!(
+                    "[{}]     {}",
+                    "Removed".bright_red(),
+                    misc::cute_path(&file_path)
+                );
+            }
         }
     }
 
@@ -298,6 +451,7 @@ fn update(game: &Game, dir: &Path, bonus_content: bool, force: bool) {
 }
 
 fn launch(file_path: &PathBuf, args: &str) {
+    println!("\n\nJoin the AlterWare Discord server:\nhttps://discord.gg/2ETE8engZM\n\n");
     println!("Launching {} {}", file_path.display(), args);
     std::process::Command::new(file_path)
         .args(args.trim().split(' '))
@@ -314,6 +468,22 @@ fn setup_env() {
         println!("{:#?}", error);
         colored::control::SHOULD_COLORIZE.set_override(false);
     });
+
+    if let Ok(system_root) = env::var("SystemRoot") {
+        if let Ok(current_dir) = env::current_dir() {
+            if current_dir.starts_with(system_root) {
+                if let Ok(current_exe) = env::current_exe() {
+                    if let Some(parent) = current_exe.parent() {
+                        if let Err(error) = env::set_current_dir(parent) {
+                            eprintln!("{:#?}", error);
+                        } else {
+                            println!("Running from the system directory. Changed working directory to the executable location.");
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 fn arg_value(args: &[String], arg: &str) -> Option<String> {
@@ -337,11 +507,11 @@ fn arg_remove_value(args: &mut Vec<String>, arg: &str) {
     };
 }
 
-fn main() {
+#[tokio::main]
+async fn main() {
     #[cfg(windows)]
     setup_env();
-
+    let mut args: Vec<String> = env::args().collect();
-    let mut args: Vec<String> = std::env::args().collect();
 
     if arg_bool(&args, "--help") {
         println!("CLI Args:");
@@ -354,6 +524,7 @@ fn main() {
         println!("    --force/-f: Force file hash recheck");
         println!("    --pass <args>: Pass arguments to the game");
         println!("    --skip-launcher-update: Skip launcher self-update");
+        println!("    --ignore-required-files: Skip required files check");
         println!(
             "\nExample:\n    alterware-launcher.exe iw4x --bonus --pass \"-console -nointro\""
         );
@@ -388,13 +559,19 @@ fn main() {
         install_path = PathBuf::from(path);
         arg_remove_value(&mut args, "-p");
     } else {
-        install_path = std::env::current_dir().unwrap();
+        install_path = env::current_dir().unwrap();
     }
 
     let mut cfg = config::load(install_path.join("alterware-launcher.json"));
 
+    let master_url = if cfg.use_https {
+        format!("https://{}", MASTER)
+    } else {
+        format!("http://{}", MASTER)
+    };
+
     if !arg_bool(&args, "--skip-launcher-update") && !cfg.skip_self_update {
-        self_update::run(cfg.update_only);
+        self_update::run(cfg.update_only).await;
     } else {
         arg_remove(&mut args, "--skip-launcher-update");
     }
@@ -417,15 +594,27 @@ fn main() {
         arg_remove(&mut args, "-f");
     }
 
+    let ignore_required_files = arg_bool(&args, "--ignore-required-files");
+    if ignore_required_files {
+        arg_remove(&mut args, "--ignore-required-files");
+    }
+
     if let Some(pass) = arg_value(&args, "--pass") {
         cfg.args = pass;
         arg_remove_value(&mut args, "--pass");
     } else if cfg.args.is_empty() {
-        cfg.args = String::from("");
+        cfg.args = String::default();
     }
 
-    let games_json = http::get_body_string(format!("{}/games.json", MASTER).as_str());
+    let games_json = http_async::get_body_string(format!("{}/games.json", master_url).as_str())
-    let games: Vec<Game> = serde_json::from_str(&games_json).unwrap();
+        .await
+        .unwrap();
+    let games: Vec<Game> = serde_json::from_str(&games_json).unwrap_or_else(|error| {
+        println!("Error parsing games.json: {:#?}", error);
+        fs::write("alterware-launcher-error.txt", &games_json).unwrap();
+        misc::stdin();
+        std::process::exit(1);
+    });
 
     let mut game: String = String::new();
     if args.len() > 1 {
@@ -441,7 +630,7 @@ fn main() {
                         }
 
                         #[cfg(windows)]
-                        setup_client_links(g, &std::env::current_dir().unwrap());
+                        setup_client_links(g, &env::current_dir().unwrap());
 
                         #[cfg(not(windows))]
                         println!("Multiple clients installed, set the client as the first argument to launch a specific client.");
@@ -462,6 +651,23 @@ fn main() {
     for g in games.iter() {
         for c in g.client.iter() {
             if c == &game {
+                if cfg.engine.is_empty() {
+                    cfg.engine = String::from(g.engine);
+                    config::save_value_s(
+                        install_path.join("alterware-launcher.json"),
+                        "engine",
+                        cfg.engine.clone(),
+                    );
+                    if cfg.engine == "iw4" && cfg.args.is_empty() {
+                        cfg.args = String::from("-stdout");
+                        config::save_value_s(
+                            install_path.join("alterware-launcher.json"),
+                            "args",
+                            cfg.args.clone(),
+                        );
+                    }
+                }
+
                 if cfg.ask_bonus_content && !g.bonus.is_empty() {
                     println!("Download bonus content? (Y/n)");
                     let input = misc::stdin().to_ascii_lowercase();
@@ -483,7 +689,11 @@ fn main() {
                     install_path.as_path(),
                     cfg.download_bonus_content,
                     cfg.force_update,
-                );
+                    Some(&game != "iw4x-sp"),
+                    &master_url,
+                    Some(ignore_required_files),
+                )
+                .await;
                 if !cfg.update_only {
                     launch(&install_path.join(format!("{}.exe", c)), &cfg.args);
                 }
@@ -493,10 +703,7 @@ fn main() {
     }
 
     #[cfg(windows)]
-    windows_launcher_install(&games);
+    windows_launcher_install(&games, &master_url).await;
-
-    #[cfg(not(windows))]
-    manual_install(&games);
 
     println!("{}", "Game not found!".bright_red());
     println!("Place the launcher in the game folder, if that doesn't work specify the client on the command line (ex. alterware-launcher.exe iw4-sp)");

src/misc.rs

@@ -1,6 +1,10 @@
-use std::{fs, path::PathBuf};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
 
 use colored::Colorize;
+use indicatif::{ProgressBar, ProgressStyle};
 
 pub fn get_file_sha1(path: &PathBuf) -> String {
     let mut sha1 = sha1_smol::Sha1::new();
@@ -35,5 +39,20 @@ pub fn human_readable_bytes(bytes: u64) -> String {
         bytes /= 1024.0;
         i += 1;
     }
-    format!("{:.2} {}", bytes, units[i])
+    format!("{:.2}{}", bytes, units[i])
+}
+
+pub fn pb_style_download(pb: &ProgressBar, state: bool) {
+    if state {
+        pb.set_style(
+            ProgressStyle::with_template("{spinner:.magenta} {msg:.magenta} > {bytes}/{total_bytes} | {bytes_per_sec} | {eta}")
+                .unwrap(),
+        );
+    } else {
+        pb.set_style(ProgressStyle::with_template("{spinner:.magenta} {msg}").unwrap());
+    }
+}
+
+pub fn cute_path(path: &Path) -> String {
+    path.to_str().unwrap().replace('\\', "/")
 }

src/self_update.rs

@@ -2,34 +2,45 @@ use crate::github;
 use crate::global::*;
 
 use semver::Version;
-#[cfg(not(windows))]
-use std::{thread, time};
 
-pub fn self_update_available() -> bool {
+pub async fn self_update_available() -> bool {
     let current_version: Version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
-    let latest_version = github::latest_version(GH_OWNER, GH_REPO);
+    let latest_version = github::latest_version(GH_OWNER, GH_REPO).await;
 
     current_version < latest_version
 }
 
 #[cfg(not(windows))]
-pub fn run(_update_only: bool) {
+pub async fn run(_update_only: bool) {
-    if self_update_available() {
+    if self_update_available().await {
         println!("A new version of the AlterWare launcher is available.");
         println!(
             "Download it at {}",
             github::latest_release_url(GH_OWNER, GH_REPO)
         );
         println!("Launching in 10 seconds..");
-        thread::sleep(time::Duration::from_secs(10));
+        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
     }
 }
 
 #[cfg(windows)]
-pub fn run(update_only: bool) {
+pub fn restart() -> std::io::Error {
+    use std::os::windows::process::CommandExt;
+    match std::process::Command::new(std::env::current_exe().unwrap())
+        .args(std::env::args().skip(1))
+        .creation_flags(0x00000010) // CREATE_NEW_CONSOLE
+        .spawn()
+    {
+        Ok(_) => std::process::exit(0),
+        Err(err) => err,
+    }
+}
+
+#[cfg(windows)]
+pub async fn run(update_only: bool) {
     use std::{fs, path::PathBuf};
 
-    use crate::http;
+    use crate::http_async;
     use crate::misc;
 
     let working_dir = std::env::current_dir().unwrap();
@@ -43,11 +54,13 @@ pub fn run(update_only: bool) {
             && (file_name.contains(".__relocated__.exe")
                 || file_name.contains(".__selfdelete__.exe"))
         {
-            fs::remove_file(file.path()).unwrap();
+            fs::remove_file(file.path()).unwrap_or_else(|_| {
+                println!("Failed to remove old launcher file.");
+            });
         }
     }
 
-    if self_update_available() {
+    if self_update_available().await {
         println!("Performing launcher self-update.");
         println!(
             "If you run into any issues, please download the latest version at {}",
@@ -66,15 +79,17 @@ pub fn run(update_only: bool) {
         } else {
             "alterware-launcher.exe"
         };
-        println!("{}", launcher_name);
+
-        http::download_file(
+        http_async::download_file(
             &format!(
                 "{}/download/{}",
                 github::latest_release_url(GH_OWNER, GH_REPO),
                 launcher_name
             ),
             &file_path,
-        );
+        )
+        .await
+        .unwrap();
 
         if !file_path.exists() {
             println!("Failed to download launcher update.");
@@ -83,12 +98,12 @@ pub fn run(update_only: bool) {
 
         self_replace::self_replace("alterware-launcher-update.exe").unwrap();
         fs::remove_file(&file_path).unwrap();
-        println!(
+
-            "Launcher updated. View the changelog at https://github.com/{}/{}/releases/latest",
+        // restarting spawns a new console, automation should manually restart on exit code 201
-            GH_OWNER, GH_REPO,
-        );
-        println!("Please restart the launcher.");
         if !update_only {
+            let restart_error = restart().to_string();
+            println!("Failed to restart launcher: {}", restart_error);
+            println!("Please restart the launcher manually.");
             misc::stdin();
         }
         std::process::exit(201);

src/structs.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 #[derive(serde::Deserialize, serde::Serialize, Clone)]
 pub struct CdnFile {
     pub name: String,
@@ -12,6 +14,21 @@ pub struct Game<'a> {
     pub references: Vec<&'a str>,
     pub app_id: u32,
     pub bonus: Vec<&'a str>,
+    pub delete: Vec<&'a str>,
+    pub required: Vec<&'a str>,
+}
+
+impl<'a> Game<'a> {
+    pub fn required_files_exist(&self, dir: &Path) -> bool {
+        for required_file in &self.required {
+            let file_path = dir.join(required_file);
+            if !file_path.exists() {
+                println!("Required file {} does not exist", file_path.display());
+                return false;
+            }
+        }
+        true
+    }
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
@@ -22,6 +39,10 @@ pub struct Config {
     pub ask_bonus_content: bool,
     pub force_update: bool,
     pub args: String,
+    #[serde(default)]
+    pub engine: String,
+    #[serde(default)]
+    pub use_https: bool,
 }
 
 impl Default for Config {
@@ -32,7 +53,9 @@ impl Default for Config {
             download_bonus_content: false,
             ask_bonus_content: true,
             force_update: false,
-            args: String::from(""),
+            args: String::default(),
+            engine: String::default(),
+            use_https: true,
         }
     }
 }