v0.6.10

Bump serde from 1.0.196 to 1.0.197

.github/dependabot.yml

@@ -3,4 +3,4 @@ updates:
   - package-ecosystem: "cargo" # See documentation for possible values
     directory: "/" # Location of package manifests
     schedule:
-      interval: "daily"
+      interval: "weekly"

.github/workflows/lint.yml

@@ -1,9 +1,3 @@
-# Based on https://github.com/actions-rs/meta/blob/master/recipes/quickstart.md
-#
-# While our "example" application has the platform-specific code,
-# for simplicity we are compiling and testing everything on the Ubuntu environment only.
-# For multi-OS testing see the `cross.yml` workflow.
-
 on: [push, pull_request]
 
 name: lint
@@ -14,18 +8,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
-          profile: minimal
           toolchain: stable
-          override: true
 
       - name: Run cargo check
-        uses: actions-rs/cargo@v1
-        continue-on-error: true  # WARNING: only for this example, remove it!
+        uses: clechasseur/rs-cargo@v2
+        continue-on-error: true
         with:
           command: check
 
@@ -34,18 +26,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
-          profile: minimal
           toolchain: stable
-          override: true
 
       - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        continue-on-error: true  # WARNING: only for this example, remove it!
+        uses: clechasseur/rs-cargo@v2
+        continue-on-error: true
         with:
           command: test
 
@@ -54,26 +44,24 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
-          profile: minimal
           toolchain: stable
-          override: true
           components: rustfmt, clippy
 
       - name: Run cargo fmt
-        uses: actions-rs/cargo@v1
-        continue-on-error: true  # WARNING: only for this example, remove it!
+        uses: clechasseur/rs-cargo@v2
+        continue-on-error: true
         with:
           command: fmt
           args: --all -- --check
 
       - name: Run cargo clippy
-        uses: actions-rs/cargo@v1
-        continue-on-error: true  # WARNING: only for this example, remove it!
+        uses: clechasseur/rs-cargo@v2
+        continue-on-error: true
         with:
           command: clippy
           args: -- -D warnings

.github/workflows/release.yml

@@ -9,24 +9,34 @@ jobs:
   create-release:
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - uses: taiki-e/create-gh-release-action@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          draft: true
+          token: ${{ secrets.GITHUB_TOKEN }}
 
   upload-assets:
     strategy:
       matrix:
-        os:
-          - ubuntu-20.04
-          - windows-latest
+        include:
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu-20.04
+          - 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@v2
+      - uses: actions/checkout@v4
       - uses: taiki-e/upload-rust-binary-action@v1
         with:
+          target: ${{ matrix.target }}
           bin: alterware-launcher
           tar: unix
           zip: windows
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Cargo.toml

@@ -1,28 +1,40 @@
 [package]
 name = "alterware-launcher"
-version = "0.2.3"
+version = "0.6.10"
 edition = "2021"
 build = "res/build.rs"
 
 [profile.release]
 opt-level = "s"
+
 panic = "abort"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-http_req = { version = "0.9.0", default-features = false, features = [
-    "rust-tls",
-] }
 sha1_smol = "1.0.0"
-serde = { version = "1.0.164", features = ["derive"] }
-serde_json = "1.0.96"
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
 rand = "0.8.5"
+semver = "1.0.22"
+colored = "2.1.0"
+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-beta.2"
+mslnk = "0.1.8"
+self-replace = "1.3.7"
 
 [build-dependencies]
 winres = "0.1.12"
 
 [package.metadata.winres]
 OriginalFilename = "alterware-launcher.exe"
-FileDescription = "AlterWare mod updater & launcher"
-ProductName = "AlterWare Launcher"
+FileDescription = "AlterWare Launcher"
+ProductName = "AlterWare Launcher"

README.md

@@ -1,10 +1,95 @@
-# alterware-launcher
+# AlterWare Launcher
 
-1. Download [latest release](https://github.com/mxve/alterware-launcher/releases/latest/download/alterware-launcher-x86_64-pc-windows-msvc.zip)
-2. Unpack the archive and place alterware-launcher.exe in the game directory
-3. Run alterware-launcher.exe, after updating the game will launch automatically
+### [AlterWare.dev](https://alterware.dev)
+
+##### 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)
 
 ---
 
-- Passing ```iw4-sp```, ```iw5-mod```, ```iw6-mod``` or ```s1-mod``` as the first argument will skip automatic game detection
-- Passing ```update``` will stop the launcher from launching the game
+## Installation
+
+1. Download the game from [Steam](https://store.steampowered.com/)
+2. Download the [latest alterware-launcher.exe](https://github.com/mxve/alterware-launcher/releases/latest/download/alterware-launcher.exe)
+3. Place alterware-launcher.exe in the game directory
+4. Run alterware-launcher.exe, after updating the game will launch automatically
+
+---
+
+#### Command line arguments
+
+- ```iw4-sp```, ```iw4x```, ```iw5-mod```, ```iw6-mod```, ```s1-mod```
+  - Skip automatic detection and launch the specified game
+    - This should always be the first argument if used
+- ```--update```, ```-u```
+  - Only update the game, don't launch it
+- ```--skip-launcher-update```
+  - Don't update the launcher
+- ```--bonus```
+  - Download bonus content
+- ```--force```, ```-f```
+  - Force file hash recheck
+- ```--path```, ```-p```
+  - Set the game path
+    - Do not include a trailing backslash in the path
+- ```--pass```
+  - Pass additional arguments to the game
+    - 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"```
+
+Some arguments can be set in alterware-launcher.json, args generally override the values of the config.
+
+---
+
+#### Config file
+alterware-launcher.json
+
+- ```update_only```
+  - See --update
+  - Default: false
+- ```skip_self_update```
+  - See --skip-launcher-update
+  - Default: false
+- ```download_bonus_content```
+  - See --bonus
+  - Default: false
+- ```ask_bonus_content```
+  - Ask the user if they want to download bonus content
+  - Default: true; false after asking
+- ```force_update```
+  - See --force
+  - Default: false
+- ```args```
+  - See --pass
+  - Default: ""
+- ```use_https```
+  - Use HTTPS for downloads
+  - Default: false
+
+---
+
+#### Support
+
+Visit the [AlterWare Forum](https://forum.alterware.dev/) or [Discord](https://discord.gg/2ETE8engZM) for support.
+
+---
+
+#### Building from Source
+
+- [Install Rust](https://rustup.rs/)
+- Clone the repository
+- Run ```cargo build --release```
+- The executable will be located in ```target/release```
+
+---
+
+### Note for server owners:
+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.

client-args.md

@@ -0,0 +1,32 @@
+# IW4x
+[github.com/iw4x/iw4x-client#command-line-arguments](https://github.com/iw4x/iw4x-client#command-line-arguments)
+
+| Argument                | Description                                    |
+|:------------------------|:-----------------------------------------------|
+| `-tests`                | Perform unit tests.                            |
+| `-entries`              | Print to the console a list of every asset as they are loaded from zonefiles. |
+| `-stdout`               | Redirect all logging output to the terminal iw4x is started from, or if there is none, creates a new terminal window to write log information in. |
+| `-console`              | Allow the game to display its own separate interactive console window. |
+| `-dedicated`            | Starts the game as a headless dedicated server. |
+| `-bigminidumps`         | Include all code sections from loaded modules in the dump. |
+| `-reallybigminidumps`   | Include data sections from all loaded modules in the dump. |
+| `-dump`                 | Write info of loaded assets to the raw folder as they are being loaded. |
+| `-nointro`              | Skip game's cinematic intro.                   |
+| `-version`              | Print IW4x build info on startup.              |
+| `-nosteam`              | Disable friends feature and do not update Steam about the game's current status just like an invisible mode. |
+| `-unprotect-dvars`      | Allow the server to modify saved/archive dvars. |
+| `-zonebuilder`          | Start the interactive zonebuilder tool console instead of starting the game. |
+| `-disable-notifies`     | Disable "Anti-CFG" checks |
+| `-disable-mongoose`     | Disable Mongoose HTTP server |
+| `-disable-rate-limit-check` | Disable RCOn rate limit checks |
+| `+<command>`            | Execute game command (ex. `+set net_port 1337`)|
+
+
+# S1-Mod, IW6-Mod
+| Argument                | Description                                    |
+|:------------------------|:-----------------------------------------------|
+| `-headless`             | Use system console                             |
+| `-dedicated`            | Dedicated server                               |
+| `-singleplayer`         | Start singleplayer; Skip launcher              |
+| `-multiplayer`          | Start multiplayer; Skip launcher               |
+| `+<command>`            | Execute game command (ex. `+set net_port 1337`)|

src/config.rs

@@ -0,0 +1,53 @@
+use crate::structs::Config;
+
+use std::{fs, path::PathBuf};
+
+pub fn load(config_path: PathBuf) -> Config {
+    if config_path.exists() {
+        let cfg = fs::read_to_string(&config_path).unwrap();
+        let cfg: Config = serde_json::from_str(&cfg).unwrap_or(Config::default());
+        return cfg;
+    }
+    save(config_path.clone(), Config::default());
+    Config::default()
+}
+
+pub fn save(config_path: PathBuf, config: Config) {
+    match fs::write(
+        config_path.clone(),
+        serde_json::to_string_pretty(&config).unwrap(),
+    ) {
+        Ok(_) => (),
+        Err(e) => match e.kind() {
+            std::io::ErrorKind::NotFound => {
+                fs::create_dir_all(config_path.parent().unwrap()).unwrap();
+                save(config_path, config);
+            }
+            _ => println!("Could not save config file, got:\n{}\n", e),
+        },
+    }
+}
+
+pub fn save_value(config_path: PathBuf, key: &str, value: bool) {
+    let mut config = load(config_path.clone());
+    match key {
+        "update_only" => config.update_only = value,
+        "skip_self_update" => config.skip_self_update = value,
+        "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

@@ -0,0 +1,24 @@
+use semver::Version;
+
+pub async fn latest_tag(owner: &str, repo: &str) -> 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 async fn latest_version(owner: &str, repo: &str) -> Version {
+    let tag = latest_tag(owner, repo).await.replace('v', "");
+    Version::parse(&tag).unwrap()
+}
+
+pub fn latest_release_url(owner: &str, repo: &str) -> String {
+    format!("https://github.com/{}/{}/releases/latest", owner, repo)
+}

src/global.rs

@@ -0,0 +1,5 @@
+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";
+pub const GH_IW4X_REPO: &str = "iw4x-client";

src/http.rs

@@ -1,25 +0,0 @@
-use std::{fs, io::Write, path::Path, str};
-
-pub fn get_body(url: &str) -> Vec<u8> {
-    let mut res: Vec<u8> = Vec::new();
-    http_req::request::get(url, &mut res).unwrap_or_else(|error| {
-        panic!("\n\n{}:\n{:?}", "Error", error);
-    });
-
-    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);
-
-    let mut f = fs::File::create(file_path).unwrap_or_else(|error| {
-        panic!("\n\n{}:\n{:?}", "Error", error);
-    });
-    f.write_all(&body).unwrap_or_else(|error| {
-        panic!("\n\n{}:\n{:?}", "Error", error);
-    });
-}

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/iw4x.rs

@@ -0,0 +1,52 @@
+use crate::github;
+use crate::global::*;
+use crate::http_async;
+use crate::misc;
+
+use colored::*;
+use std::{fs, path::Path};
+
+pub fn local_revision(dir: &Path) -> u16 {
+    if let Ok(revision) = fs::read_to_string(dir.join(".iw4xrevision")) {
+        misc::rev_to_int(&revision)
+    } else {
+        0
+    }
+}
+
+pub async fn remote_revision() -> u16 {
+    misc::rev_to_int(&github::latest_tag(GH_IW4X_OWNER, GH_IW4X_REPO).await)
+}
+
+pub async fn update(dir: &Path) {
+    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(),
+        misc::cute_path(&dir.join("iw4x.dll"))
+    );
+    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,110 +1,620 @@
-mod http;
-use std::{fs, path::PathBuf};
+mod config;
+mod github;
+mod global;
+mod http_async;
+mod iw4x;
+mod misc;
+mod self_update;
+mod structs;
 
-#[derive(serde::Deserialize, serde::Serialize)]
-struct CdnFile {
-    name: String,
-    size: u32,
-    hash: String,
-}
+use global::*;
+use structs::*;
 
-#[derive(serde::Deserialize, serde::Serialize)]
-struct Game<'a> {
-    engine: &'a str,
-    client: &'a str,
-    references: Vec<&'a str>,
-}
+use colored::*;
+use indicatif::ProgressBar;
+#[cfg(windows)]
+use mslnk::ShellLink;
+use std::{borrow::Cow, collections::HashMap, env, fs, path::Path, path::PathBuf};
+#[cfg(windows)]
+use steamlocate::SteamDir;
 
-const MASTER: &str = "https://master.alterware.dev";
+#[cfg(windows)]
+fn get_installed_games(games: &Vec<Game>) -> Vec<(u32, PathBuf)> {
+    let mut installed_games = Vec::new();
+    let steamdir_result = SteamDir::locate();
 
-fn file_get_sha1(path: &PathBuf) -> String {
-    let mut sha1 = sha1_smol::Sha1::new();
-    sha1.update(&fs::read(path).unwrap());
-    sha1.digest().to_string()
-}
+    let steamdir = match steamdir_result {
+        Ok(steamdir) => steamdir,
+        Err(error) => {
+            println!("Error locating Steam: {}", error);
+            return installed_games;
+        }
+    };
 
-fn update(game: &Game) {
-    let cdn_info: Vec<CdnFile> = serde_json::from_str(&http::get_body_string(
-        format!(
-            "{}/files.json?{}",
-            MASTER,
-            rand::Rng::gen_range(&mut rand::thread_rng(), 0..1000)
-        )
-        .as_str(),
-    ))
-    .unwrap();
-
-    let mut files_to_update: Vec<CdnFile> = Vec::new();
-    for file in cdn_info {
-        if file.name.starts_with(game.engine) {
-            files_to_update.push(file);
+    for game in games {
+        if let Ok(Some((app, library))) = steamdir.find_app(game.app_id) {
+            let game_path = library
+                .path()
+                .join("steamapps")
+                .join("common")
+                .join(&app.install_dir);
+            installed_games.push((game.app_id, game_path));
         }
     }
 
-    for file in files_to_update {
-        let file_path = PathBuf::from(&file.name.replace(&format!("{}/", game.engine), ""));
-        if file_path.exists() {
-            let sha1_local = file_get_sha1(&file_path).to_lowercase();
-            let sha1_remote = file.hash.to_lowercase();
-            if sha1_local != sha1_remote {
-                println!(
-                    "Updating {}...\nLocal hash: {}\nRemote hash: {}",
-                    file_path.display(),
-                    sha1_local,
-                    sha1_remote
-                );
-                http::download_file(
-                    &format!(
-                        "{}/{}?{}",
-                        MASTER,
-                        file.name,
-                        rand::Rng::gen_range(&mut rand::thread_rng(), 0..1000)
-                    ),
-                    &file_path,
-                );
-            }
-        } else {
-            println!("Downloading {}...", file_path.display());
-            if let Some(parent) = file_path.parent() {
-                if !parent.exists() {
-                    fs::create_dir_all(parent).unwrap();
-                }
-            }
-            http::download_file(
-                &format!(
-                    "{}/{}?{}",
-                    MASTER,
-                    file.name,
-                    rand::Rng::gen_range(&mut rand::thread_rng(), 0..1000)
-                ),
-                &file_path,
+    installed_games
+}
+
+#[cfg(windows)]
+fn create_shortcut(path: &Path, target: &Path, icon: String, args: String) {
+    if let Ok(mut sl) = ShellLink::new(target) {
+        sl.set_arguments(Some(args));
+        sl.set_icon_location(Some(icon));
+        sl.create_lnk(path).unwrap_or_else(|error| {
+            println!("Error creating shortcut.\n{:#?}", error);
+        });
+    } else {
+        println!("Error creating shortcut.");
+    }
+}
+
+#[cfg(windows)]
+fn setup_client_links(game: &Game, game_dir: &Path) {
+    if game.client.len() > 1 {
+        println!("Multiple clients installed, use the shortcuts (launch-<client>.lnk in the game directory or on the desktop) to launch a specific client.");
+    }
+
+    for c in game.client.iter() {
+        create_shortcut(
+            &game_dir.join(format!("launch-{}.lnk", c)),
+            &game_dir.join("alterware-launcher.exe"),
+            game_dir
+                .join(format!("{}.exe", c))
+                .to_string_lossy()
+                .into_owned(),
+            c.to_string(),
+        );
+    }
+}
+
+#[cfg(windows)]
+fn setup_desktop_links(path: &Path, game: &Game) {
+    println!("Create Desktop shortcut? (Y/n)");
+    let input = misc::stdin().to_ascii_lowercase();
+
+    if input == "y" || input.is_empty() {
+        let desktop = PathBuf::from(&format!("{}\\Desktop", env::var("USERPROFILE").unwrap()));
+
+        for c in game.client.iter() {
+            create_shortcut(
+                &desktop.join(format!("{}.lnk", c)),
+                &path.join("alterware-launcher.exe"),
+                path.join(format!("{}.exe", c))
+                    .to_string_lossy()
+                    .into_owned(),
+                c.to_string(),
             );
         }
     }
 }
 
-fn launch(file_path: &PathBuf) {
-    println!("Launching {}...", file_path.display());
-    std::process::Command::new(file_path)
-        .spawn()
-        .unwrap()
-        .wait()
-        .unwrap();
+#[cfg(windows)]
+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, None, master_url, None).await;
 }
 
-fn main() {
-    let mut args: Vec<String> = std::env::args().collect();
+#[cfg(windows)]
+async fn windows_launcher_install(games: &Vec<Game<'_>>, master_url: &String) {
+    println!(
+        "{}",
+        "No game specified/found. Checking for installed Steam games..".yellow()
+    );
+    let installed_games = get_installed_games(games);
 
-    let games_json = http::get_body_string(format!("{}/games.json", MASTER).as_str());
-    let games: Vec<Game> = serde_json::from_str(&games_json).unwrap();
+    if !installed_games.is_empty() {
+        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, 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);
+            }
+        }
 
-    let mut update_only = false;
-    if args.contains(&String::from("update")) {
-        update_only = true;
-        args.iter()
-            .position(|r| r == "update")
-            .map(|e| args.remove(e));
+        println!("Installed games:");
+
+        for (id, path) in installed_games.iter() {
+            println!("{}: {}", id, path.display());
+        }
+
+        println!("Enter the ID of the game you want to install the AlterWare client for:");
+        let input: u32 = misc::stdin().parse().unwrap();
+
+        for (id, path) in installed_games.iter() {
+            if *id == input {
+                let game = games.iter().find(|&g| g.app_id == input).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, 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;
+            }
+        }
+        std::process::exit(0);
+    } else {
+        println!(
+            "No installed games found. Make sure to place the launcher in the game directory."
+        );
+        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;
+    for file in cdn_info {
+        if !file.name.starts_with(&remote_dir) || file.name == "iw4/iw4x.dll" {
+            continue;
+        }
+        size += file.size as u64;
+    }
+    size
+}
+
+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![];
+
+    for file in cdn_info {
+        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(), "");
+        let file_path = dir.join(file_name);
+        if file_path.exists() {
+            let sha1_local = hashes
+                .get(file_name)
+                .map(Cow::Borrowed)
+                .unwrap_or_else(|| Cow::Owned(misc::get_file_sha1(&file_path)))
+                .to_string();
+
+            if sha1_local != sha1_remote {
+                files_to_download.push(file.clone());
+            } else {
+                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());
+        }
+    }
+
+    if files_to_download.is_empty() {
+        pb.println(format!(
+            "[{}]        No files to download for {}",
+            "Info".bright_magenta(),
+            remote_dir
+        ));
+        return;
+    }
+    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);
+        if let Some(parent) = file_path.parent() {
+            if !parent.exists() {
+                fs::create_dir_all(parent).unwrap();
+            }
+        }
+        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);
+}
+
+async fn update(
+    game: &Game<'_>,
+    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");
+    if hash_file.exists() && !force {
+        let hash_file = fs::read_to_string(hash_file).unwrap();
+        for line in hash_file.lines() {
+            let mut split = line.split_whitespace();
+            let hash = split.next().unwrap();
+            let file = split.next().unwrap();
+            hashes.insert(file.to_owned(), hash.to_owned());
+        }
+    }
+
+    if game.engine == "iw4" {
+        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,
+                &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)
+                );
+            }
+        }
+    }
+
+    let mut hash_file_content = String::new();
+    for (file, hash) in hashes.iter() {
+        hash_file_content.push_str(&format!("{} {}\n", hash, file));
+    }
+    fs::write(dir.join(".sha-sums"), hash_file_content).unwrap();
+}
+
+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(' '))
+        .current_dir(file_path.parent().unwrap())
+        .spawn()
+        .expect("Failed to launch the game")
+        .wait()
+        .expect("Failed to wait for the game process to finish");
+}
+
+#[cfg(windows)]
+fn setup_env() {
+    colored::control::set_virtual_terminal(true).unwrap_or_else(|error| {
+        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> {
+    args.iter()
+        .position(|r| r == arg)
+        .map(|e| args[e + 1].clone())
+}
+
+fn arg_bool(args: &[String], arg: &str) -> bool {
+    args.iter().any(|r| r == arg)
+}
+
+fn arg_remove(args: &mut Vec<String>, arg: &str) {
+    args.iter().position(|r| r == arg).map(|e| args.remove(e));
+}
+
+fn arg_remove_value(args: &mut Vec<String>, arg: &str) {
+    if let Some(e) = args.iter().position(|r| r == arg) {
+        args.remove(e);
+        args.remove(e);
+    };
+}
+
+#[tokio::main]
+async fn main() {
+    #[cfg(windows)]
+    setup_env();
+    let mut args: Vec<String> = env::args().collect();
+
+    if arg_bool(&args, "--help") {
+        println!("CLI Args:");
+        println!("    <client>: Specify the client to launch");
+        println!("    --help: Display this help message");
+        println!("    --version: Display the launcher version");
+        println!("    --path/-p <path>: Specify the game directory");
+        println!("    --update/-u: Update only, don't launch the game");
+        println!("    --bonus: Download bonus content");
+        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\""
+        );
+        return;
+    }
+
+    if arg_bool(&args, "--version") || arg_bool(&args, "-v") {
+        println!(
+            "{} v{}",
+            "AlterWare Launcher".bright_green(),
+            env!("CARGO_PKG_VERSION")
+        );
+        println!("https://github.com/{}/{}", GH_OWNER, GH_REPO);
+        println!(
+            "\n{}{}{}{}{}{}{}",
+            "For ".on_black(),
+            "Alter".bright_blue().on_black().underline(),
+            "Ware".white().on_black().underline(),
+            ".dev".on_black().underline(),
+            " by ".on_black(),
+            "mxve".bright_magenta().on_black().underline(),
+            ".de".on_black().underline()
+        );
+        return;
+    }
+
+    let install_path: PathBuf;
+    if let Some(path) = arg_value(&args, "--path") {
+        install_path = PathBuf::from(path);
+        arg_remove_value(&mut args, "--path");
+    } else if let Some(path) = arg_value(&args, "-p") {
+        install_path = PathBuf::from(path);
+        arg_remove_value(&mut args, "-p");
+    } else {
+        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).await;
+    } else {
+        arg_remove(&mut args, "--skip-launcher-update");
+    }
+
+    if arg_bool(&args, "--update") || arg_bool(&args, "-u") {
+        cfg.update_only = true;
+        arg_remove(&mut args, "--update");
+        arg_remove(&mut args, "-u");
+    }
+
+    if arg_bool(&args, "--bonus") {
+        cfg.download_bonus_content = true;
+        cfg.ask_bonus_content = false;
+        arg_remove(&mut args, "--bonus");
+    }
+
+    if arg_bool(&args, "--force") || arg_bool(&args, "-f") {
+        cfg.force_update = true;
+        arg_remove(&mut args, "--force");
+        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::default();
+    }
+
+    let games_json = http_async::get_body_string(format!("{}/games.json", master_url).as_str())
+        .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 {
@@ -112,8 +622,26 @@ fn main() {
     } else {
         'main: for g in games.iter() {
             for r in g.references.iter() {
-                if std::path::Path::new(r).exists() {
-                    game = String::from(g.client);
+                if install_path.join(r).exists() {
+                    if g.client.len() > 1 {
+                        if cfg.update_only {
+                            game = String::from(g.client[0]);
+                            break 'main;
+                        }
+
+                        #[cfg(windows)]
+                        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.");
+                        println!("Select a client to launch:");
+                        for (i, c) in g.client.iter().enumerate() {
+                            println!("{}: {}", i, c);
+                        }
+                        game = String::from(g.client[misc::stdin().parse::<usize>().unwrap()]);
+                        break 'main;
+                    }
+                    game = String::from(g.client[0]);
                     break 'main;
                 }
             }
@@ -121,17 +649,63 @@ fn main() {
     }
 
     for g in games.iter() {
-        if g.client == game {
-            update(g);
-            if update_only {
+        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();
+                    cfg.download_bonus_content = input != "n";
+                    config::save_value(
+                        install_path.join("alterware-launcher.json"),
+                        "download_bonus_content",
+                        cfg.download_bonus_content,
+                    );
+                    config::save_value(
+                        install_path.join("alterware-launcher.json"),
+                        "ask_bonus_content",
+                        false,
+                    );
+                }
+
+                update(
+                    g,
+                    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);
+                }
                 return;
             }
-            launch(&PathBuf::from(format!("{}.exe", g.client)));
-            return;
         }
     }
 
-    println!("Game not found!");
+    #[cfg(windows)]
+    windows_launcher_install(&games, &master_url).await;
+
+    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)");
     println!("Press enter to exit...");
     std::io::stdin().read_line(&mut String::new()).unwrap();

src/misc.rs

@@ -0,0 +1,58 @@
+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();
+    sha1.update(&fs::read(path).unwrap());
+    sha1.digest().to_string()
+}
+
+pub fn stdin() -> String {
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    input.trim().to_string()
+}
+
+pub fn rev_to_int(rev: &str) -> u16 {
+    rev.strip_prefix('r')
+        .unwrap_or("0")
+        .parse::<u16>()
+        .unwrap_or(0)
+}
+
+pub fn fatal_error(error: &str) {
+    println!("\n\n{}:\n{}", "Error".bright_red(), error);
+    stdin();
+    std::process::exit(1);
+}
+
+pub fn human_readable_bytes(bytes: u64) -> String {
+    let mut bytes = bytes as f64;
+    let mut i = 0;
+    let units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    while bytes > 1024.0 {
+        bytes /= 1024.0;
+        i += 1;
+    }
+    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

@@ -0,0 +1,111 @@
+use crate::github;
+use crate::global::*;
+
+use semver::Version;
+
+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).await;
+
+    current_version < latest_version
+}
+
+#[cfg(not(windows))]
+pub async fn run(_update_only: bool) {
+    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..");
+        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
+    }
+}
+
+#[cfg(windows)]
+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_async;
+    use crate::misc;
+
+    let working_dir = std::env::current_dir().unwrap();
+    let files = fs::read_dir(&working_dir).unwrap();
+
+    for file in files {
+        let file = file.unwrap();
+        let file_name = file.file_name().into_string().unwrap();
+
+        if file_name.contains("alterware-launcher")
+            && (file_name.contains(".__relocated__.exe")
+                || file_name.contains(".__selfdelete__.exe"))
+        {
+            fs::remove_file(file.path()).unwrap_or_else(|_| {
+                println!("Failed to remove old launcher file.");
+            });
+        }
+    }
+
+    if self_update_available().await {
+        println!("Performing launcher self-update.");
+        println!(
+            "If you run into any issues, please download the latest version at {}",
+            github::latest_release_url(GH_OWNER, GH_REPO)
+        );
+
+        let update_binary = PathBuf::from("alterware-launcher-update.exe");
+        let file_path = working_dir.join(&update_binary);
+
+        if update_binary.exists() {
+            fs::remove_file(&update_binary).unwrap();
+        }
+
+        let launcher_name = if cfg!(target_arch = "x86") {
+            "alterware-launcher-x86.exe"
+        } else {
+            "alterware-launcher.exe"
+        };
+
+        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.");
+            return;
+        }
+
+        self_replace::self_replace("alterware-launcher-update.exe").unwrap();
+        fs::remove_file(&file_path).unwrap();
+
+        // restarting spawns a new console, automation should manually restart on exit code 201
+        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

@@ -0,0 +1,61 @@
+use std::path::Path;
+
+#[derive(serde::Deserialize, serde::Serialize, Clone)]
+pub struct CdnFile {
+    pub name: String,
+    pub size: u32,
+    pub hash: String,
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct Game<'a> {
+    pub engine: &'a str,
+    pub client: Vec<&'a str>,
+    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)]
+pub struct Config {
+    pub update_only: bool,
+    pub skip_self_update: bool,
+    pub download_bonus_content: bool,
+    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 {
+    fn default() -> Self {
+        Self {
+            update_only: false,
+            skip_self_update: false,
+            download_bonus_content: false,
+            ask_bonus_content: true,
+            force_update: false,
+            args: String::default(),
+            engine: String::default(),
+            use_https: true,
+        }
+    }
+}