Compare commits
No commits in common. "main" and "v0.2.2" have entirely different histories.
2
.github/dependabot.yml
vendored
2
.github/dependabot.yml
vendored
@ -3,4 +3,4 @@ updates:
|
||||
- package-ecosystem: "cargo" # See documentation for possible values
|
||||
directory: "/" # Location of package manifests
|
||||
schedule:
|
||||
interval: "weekly"
|
||||
interval: "daily"
|
||||
|
||||
40
.github/workflows/lint.yml
vendored
40
.github/workflows/lint.yml
vendored
@ -1,3 +1,9 @@
|
||||
# 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
|
||||
@ -8,16 +14,18 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout sources
|
||||
uses: actions/checkout@v4
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Install stable toolchain
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: stable
|
||||
override: true
|
||||
|
||||
- name: Run cargo check
|
||||
uses: clechasseur/rs-cargo@v2
|
||||
continue-on-error: true
|
||||
uses: actions-rs/cargo@v1
|
||||
continue-on-error: true # WARNING: only for this example, remove it!
|
||||
with:
|
||||
command: check
|
||||
|
||||
@ -26,16 +34,18 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout sources
|
||||
uses: actions/checkout@v4
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Install stable toolchain
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: stable
|
||||
override: true
|
||||
|
||||
- name: Run cargo test
|
||||
uses: clechasseur/rs-cargo@v2
|
||||
continue-on-error: true
|
||||
uses: actions-rs/cargo@v1
|
||||
continue-on-error: true # WARNING: only for this example, remove it!
|
||||
with:
|
||||
command: test
|
||||
|
||||
@ -44,24 +54,26 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout sources
|
||||
uses: actions/checkout@v4
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Install stable toolchain
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: stable
|
||||
override: true
|
||||
components: rustfmt, clippy
|
||||
|
||||
- name: Run cargo fmt
|
||||
uses: clechasseur/rs-cargo@v2
|
||||
continue-on-error: true
|
||||
uses: actions-rs/cargo@v1
|
||||
continue-on-error: true # WARNING: only for this example, remove it!
|
||||
with:
|
||||
command: fmt
|
||||
args: --all -- --check
|
||||
|
||||
- name: Run cargo clippy
|
||||
uses: clechasseur/rs-cargo@v2
|
||||
continue-on-error: true
|
||||
uses: actions-rs/cargo@v1
|
||||
continue-on-error: true # WARNING: only for this example, remove it!
|
||||
with:
|
||||
command: clippy
|
||||
args: -- -D warnings
|
||||
|
||||
24
.github/workflows/release.yml
vendored
24
.github/workflows/release.yml
vendored
@ -9,32 +9,22 @@ jobs:
|
||||
create-release:
|
||||
runs-on: ubuntu-20.04
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- uses: taiki-e/create-gh-release-action@v1
|
||||
with:
|
||||
draft: true
|
||||
token: ${{ secrets.GITHUB_TOKEN }}
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
upload-assets:
|
||||
strategy:
|
||||
matrix:
|
||||
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
|
||||
os:
|
||||
- ubuntu-20.04
|
||||
- windows-latest
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- uses: taiki-e/upload-rust-binary-action@v1
|
||||
with:
|
||||
target: ${{ matrix.target }}
|
||||
bin: alterware-launcher
|
||||
tar: unix
|
||||
zip: windows
|
||||
|
||||
1440
Cargo.lock
generated
1440
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
26
Cargo.toml
26
Cargo.toml
@ -1,40 +1,28 @@
|
||||
[package]
|
||||
name = "alterware-launcher"
|
||||
version = "0.6.10"
|
||||
version = "0.2.2"
|
||||
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.197", features = ["derive"] }
|
||||
serde_json = "1.0.114"
|
||||
serde = { version = "1.0.164", features = ["derive"] }
|
||||
serde_json = "1.0.96"
|
||||
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 Launcher"
|
||||
FileDescription = "AlterWare mod updater & launcher"
|
||||
ProductName = "AlterWare Launcher"
|
||||
96
README.md
96
README.md
@ -1,95 +1,9 @@
|
||||
# AlterWare Launcher
|
||||
# alterware-launcher
|
||||
|
||||
### [AlterWare.dev](https://alterware.dev)
|
||||
|
||||
##### IW4x | IW4-SP | IW5-Mod | IW6-Mod | S1-Mod
|
||||
|
||||
  
|
||||
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 MW2/MW3/Ghosts game directory
|
||||
3. Run alterware-launcher.exe
|
||||
|
||||
---
|
||||
|
||||
## 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.
|
||||
- Passing iw4-sp, iw5-mod or iw6-mod as the first argument will skip automatic game detection
|
||||
@ -1,32 +0,0 @@
|
||||
# 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`)|
|
||||
@ -1,53 +0,0 @@
|
||||
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);
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
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)
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
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";
|
||||
25
src/http.rs
Normal file
25
src/http.rs
Normal file
@ -0,0 +1,25 @@
|
||||
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);
|
||||
});
|
||||
}
|
||||
@ -1,127 +0,0 @@
|
||||
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())
|
||||
}
|
||||
52
src/iw4x.rs
52
src/iw4x.rs
@ -1,52 +0,0 @@
|
||||
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();
|
||||
}
|
||||
735
src/main.rs
735
src/main.rs
@ -1,620 +1,102 @@
|
||||
mod config;
|
||||
mod github;
|
||||
mod global;
|
||||
mod http_async;
|
||||
mod iw4x;
|
||||
mod misc;
|
||||
mod self_update;
|
||||
mod structs;
|
||||
mod http;
|
||||
use std::{fs, path::PathBuf};
|
||||
|
||||
use global::*;
|
||||
use structs::*;
|
||||
|
||||
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;
|
||||
|
||||
#[cfg(windows)]
|
||||
fn get_installed_games(games: &Vec<Game>) -> Vec<(u32, PathBuf)> {
|
||||
let mut installed_games = Vec::new();
|
||||
let steamdir_result = SteamDir::locate();
|
||||
|
||||
let steamdir = match steamdir_result {
|
||||
Ok(steamdir) => steamdir,
|
||||
Err(error) => {
|
||||
println!("Error locating Steam: {}", error);
|
||||
return installed_games;
|
||||
}
|
||||
};
|
||||
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
installed_games
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
struct CdnFile {
|
||||
name: String,
|
||||
size: u32,
|
||||
hash: String,
|
||||
}
|
||||
|
||||
#[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.");
|
||||
}
|
||||
#[derive(serde::Deserialize, serde::Serialize)]
|
||||
struct Game<'a> {
|
||||
engine: &'a str,
|
||||
client: &'a str,
|
||||
references: Vec<&'a str>,
|
||||
}
|
||||
|
||||
#[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.");
|
||||
}
|
||||
const MASTER: &str = "https://master.alterware.dev";
|
||||
|
||||
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(),
|
||||
);
|
||||
}
|
||||
fn file_get_sha1(path: &PathBuf) -> String {
|
||||
let mut sha1 = sha1_smol::Sha1::new();
|
||||
sha1.update(&fs::read(path).unwrap());
|
||||
sha1.digest().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();
|
||||
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();
|
||||
|
||||
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(),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[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;
|
||||
}
|
||||
|
||||
#[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);
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
let mut files_to_update: Vec<CdnFile> = Vec::new();
|
||||
for file in cdn_info {
|
||||
if !file.name.starts_with(&remote_dir) || file.name == "iw4/iw4x.dll" {
|
||||
continue;
|
||||
if file.name.starts_with(game.engine) {
|
||||
files_to_update.push(file);
|
||||
}
|
||||
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);
|
||||
for file in files_to_update {
|
||||
let file_path = PathBuf::from(&file.name.replace(&format!("{}/", game.engine), ""));
|
||||
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();
|
||||
|
||||
let sha1_local = file_get_sha1(&file_path).to_lowercase();
|
||||
let sha1_remote = file.hash.to_lowercase();
|
||||
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());
|
||||
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 {
|
||||
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);
|
||||
println!("Downloading {}...", file_path.display());
|
||||
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),
|
||||
http::download_file(
|
||||
&format!(
|
||||
"{}/{}?{}",
|
||||
MASTER,
|
||||
file.name,
|
||||
rand::Rng::gen_range(&mut rand::thread_rng(), 0..1000)
|
||||
),
|
||||
&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);
|
||||
fn launch(file_path: &PathBuf) {
|
||||
println!("Launching {}...", file_path.display());
|
||||
std::process::Command::new(file_path)
|
||||
.args(args.trim().split(' '))
|
||||
.current_dir(file_path.parent().unwrap())
|
||||
.spawn()
|
||||
.expect("Failed to launch the game")
|
||||
.unwrap()
|
||||
.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);
|
||||
});
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
|
||||
let games_json = http::get_body_string(format!("{}/games.json", MASTER).as_str());
|
||||
let games: Vec<Game> = serde_json::from_str(&games_json).unwrap();
|
||||
|
||||
let mut game: String = String::new();
|
||||
if args.len() > 1 {
|
||||
@ -622,26 +104,8 @@ async fn main() {
|
||||
} else {
|
||||
'main: for g in games.iter() {
|
||||
for r in g.references.iter() {
|
||||
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]);
|
||||
if std::path::Path::new(r).exists() {
|
||||
game = String::from(g.client);
|
||||
break 'main;
|
||||
}
|
||||
}
|
||||
@ -649,63 +113,14 @@ async 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();
|
||||
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);
|
||||
}
|
||||
if g.client == game {
|
||||
update(g);
|
||||
launch(&PathBuf::from(format!("{}.exe", g.client)));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
windows_launcher_install(&games, &master_url).await;
|
||||
|
||||
println!("{}", "Game not found!".bright_red());
|
||||
println!("Game not found!");
|
||||
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();
|
||||
|
||||
58
src/misc.rs
58
src/misc.rs
@ -1,58 +0,0 @@
|
||||
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('\\', "/")
|
||||
}
|
||||
@ -1,111 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@ -1,61 +0,0 @@
|
||||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user