Rework to allow wine prefix selection for games

maxima-bootstrap/src/main.rs

@@ -132,6 +132,7 @@ async fn platform_launch(args: BootstrapLaunchArgs) -> Result<(), NativeError> {
         None,
         false,
         CommandType::WaitForExitAndRun,
+        Some(&args.slug),
     )
     .await?;
 

maxima-cli/src/main.rs

@@ -32,8 +32,6 @@ use maxima::{
         clients::JUNO_PC_CLIENT_ID,
         cloudsync::CloudSyncLockMode,
         launch::{self, LaunchMode, LaunchOptions},
-        library::OwnedTitle,
-        manifest::{self, MANIFEST_RELATIVE_PATH},
         service_layer::{
             ServiceGetBasicPlayerRequestBuilder, ServiceGetLegacyCatalogDefsRequestBuilder,
             ServiceLegacyOffer, ServicePlayer, SERVICE_REQUEST_GETBASICPLAYER,
@@ -43,7 +41,11 @@ use maxima::{
     },
     ooa,
     rtm::client::BasicPresence,
-    util::{log::init_logger, native::take_foreground_focus, registry::check_registry_validity},
+    util::{
+        log::init_logger,
+        native::{maxima_dir, take_foreground_focus},
+        registry::check_registry_validity,
+    },
 };
 
 lazy_static! {
@@ -70,6 +72,7 @@ enum Mode {
     ListGames,
     LocateGame {
         path: String,
+        slug: String,
     },
     CloudSync {
         game_slug: String,
@@ -295,13 +298,21 @@ async fn startup() -> Result<()> {
                     }
                 }
             } else {
-                slug
+                slug.clone()
             };
 
-            start_game(&offer_id, game_path, game_args, login, maxima_arc.clone()).await
+            start_game(
+                &offer_id,
+                &slug,
+                game_path,
+                game_args,
+                login,
+                maxima_arc.clone(),
+            )
+            .await
         }
         Mode::ListGames => list_games(maxima_arc.clone()).await,
-        Mode::LocateGame { path } => locate_game(maxima_arc.clone(), &path).await,
+        Mode::LocateGame { path, slug } => locate_game(maxima_arc.clone(), &path, &slug).await,
         Mode::CloudSync { game_slug, write } => {
             do_cloud_sync(maxima_arc.clone(), &game_slug, write).await
         }
@@ -355,10 +366,9 @@ async fn run_interactive(maxima_arc: LockedMaxima) -> Result<()> {
 }
 
 async fn interactive_start_game(maxima_arc: LockedMaxima) -> Result<()> {
-    let offer_id = {
-        let mut maxima = maxima_arc.lock().await;
-
-        let mut owned_games = Vec::new();
+    let mut maxima = maxima_arc.lock().await;
+    let mut owned_games = Vec::new();
+    let owned_games_strs = {
         for game in maxima.mut_library().games().await? {
             if !game.base_offer().is_installed().await {
                 continue;
@@ -367,25 +377,27 @@ async fn interactive_start_game(maxima_arc: LockedMaxima) -> Result<()> {
             owned_games.push(game);
         }
 
-        let owned_games_strs = owned_games
+        owned_games
             .iter()
             .map(|g| g.name())
-            .collect::<Vec<String>>();
-
-        let name = Select::new("What game would you like to play?", owned_games_strs).prompt()?;
-        let game: &OwnedTitle = owned_games.iter().find(|g| g.name() == name).unwrap();
-        game.base_offer().offer_id().to_owned()
+            .collect::<Vec<String>>()
     };
 
-    start_game(&offer_id, None, Vec::new(), None, maxima_arc.clone()).await?;
+    let name = Select::new("What game would you like to play?", owned_games_strs).prompt()?;
+    let game = owned_games.iter().find(|g| g.name() == name).unwrap();
+
+    let offer_id = game.base_offer().offer_id().to_owned().clone();
+    let slug = game.base_offer().slug().to_owned().clone();
+    drop(maxima); // To unlock before starting the game, since start_game will also need to lock
+    start_game(&offer_id, &slug, None, Vec::new(), None, maxima_arc.clone()).await?;
 
     Ok(())
 }
 
 async fn interactive_install_game(maxima_arc: LockedMaxima) -> Result<()> {
     let mut maxima = maxima_arc.lock().await;
 
-    let offer_id = {
+    let game = {
         let mut owned_games = Vec::new();
         for game in maxima.mut_library().games().await? {
             if game.base_offer().is_installed().await {
@@ -402,10 +414,16 @@ async fn interactive_install_game(maxima_arc: LockedMaxima) -> Result<()> {
 
         let name =
             Select::new("What game would you like to install?", owned_games_strs).prompt()?;
-        let game = owned_games.iter().find(|g| g.name() == name).unwrap();
-        game.base_offer().offer_id().to_owned()
+        owned_games
+            .iter()
+            .find(|g| g.name() == name)
+            .unwrap()
+            .clone()
     };
 
+    let offer_id = game.base_offer().offer_id().to_owned();
+    let slug = game.base_offer().slug().to_owned();
+
     let builds = maxima
         .content_manager()
         .service()
@@ -423,6 +441,18 @@ async fn interactive_install_game(maxima_arc: LockedMaxima) -> Result<()> {
         Text::new("Where would you like to install the game? (must be an absolute path)")
             .prompt()?,
     );
+
+    #[cfg(unix)]
+    let wine_prefix = {
+        let input =
+            Text::new("Where do you want to store the Wine prefix? (must be an absolute path)")
+                .prompt()?;
+        PathBuf::from(input)
+    };
+
+    #[cfg(not(unix))]
+    let wine_prefix = PathBuf::new();
+
     if !path.is_absolute() {
         error!("Path {:?} is not absolute.", path);
         return Ok(());
@@ -432,6 +462,8 @@ async fn interactive_install_game(maxima_arc: LockedMaxima) -> Result<()> {
         .offer_id(offer_id)
         .build_id(build.build_id().to_owned())
         .path(path.clone())
+        .slug(slug) // Needs the slug here for the manifest touchup after installation, which needs to know the wine prefix path
+        .wine_prefix(Some(wine_prefix))
         .build()?;
 
     let start_time = Instant::now();
@@ -622,7 +654,7 @@ async fn juno_token_refresh(maxima_arc: LockedMaxima) -> Result<()> {
 }
 
 async fn read_license_file(content_id: &str) -> Result<()> {
-    let path = ooa::get_license_dir()?.join(format!("{}.dlf", content_id));
+    let path = ooa::get_license_dir(None)?.join(format!("{}.dlf", content_id));
     let mut data = tokio::fs::read(path).await?;
     data.drain(0..65); // Signature
 
@@ -666,8 +698,8 @@ async fn get_user_by_id(maxima_arc: LockedMaxima, user_id: &str) -> Result<()> {
     Ok(())
 }
 
-async fn get_game_by_slug(maxima_arc: LockedMaxima, slug: &str) -> Result<()> {
-    let maxima = maxima_arc.lock().await;
+async fn get_game_by_slug(maxima_arc: LockedMaxima, _slug: &str) -> Result<()> {
+    let _maxima = maxima_arc.lock().await;
 
     // match maxima.owned_game_by_slug(slug).await {
     //     Ok(game) => info!("Game: {}", game.id()),
@@ -768,10 +800,8 @@ async fn list_games(maxima_arc: LockedMaxima) -> Result<()> {
     Ok(())
 }
 
-async fn locate_game(maxima_arc: LockedMaxima, path: &str) -> Result<()> {
+async fn locate_game(maxima_arc: LockedMaxima, path: &str, slug: &str) -> Result<()> {
     let path = PathBuf::from(path);
-    let manifest = manifest::read(path.join(MANIFEST_RELATIVE_PATH)).await?;
-    manifest.run_touchup(&path).await?;
     info!("Installed!");
     Ok(())
 }
@@ -809,6 +839,7 @@ async fn do_cloud_sync(maxima_arc: LockedMaxima, game_slug: &str, write: bool) -
 
 async fn start_game(
     offer_id: &str,
+    slug: &str,
     game_path_override: Option<String>,
     game_args: Vec<String>,
     login: Option<String>,

maxima-lib/Cargo.toml

@@ -76,6 +76,7 @@ gethostname = "0.5.0"
 thiserror = "2.0.12"
 url = "2.5.2"
 http = "0.2.12"
+globset = "0.4"
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.9", features = [

maxima-lib/src/content/downloader.rs

@@ -25,7 +25,7 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use derive_getters::Getters;
 use flate2::bufread::DeflateDecoder as BufreadDeflateDecoder;
 use futures::{Stream, StreamExt, TryStreamExt};
-use log::{debug, error, info, warn};
+use log::{debug, error, warn};
 use reqwest::Client;
 use strum_macros::Display;
 use thiserror::Error;

maxima-lib/src/content/exclusion.rs

@@ -0,0 +1,38 @@
+use crate::util::native::maxima_dir;
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use log::{error, info, warn};
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+
+pub fn get_exclusion_list(slug: &str) -> GlobSet {
+    let mut builder = GlobSetBuilder::new();
+
+    if let Ok(dir) = maxima_dir()
+    // Checks to make sure maxima directory exists
+    {
+        let filepath = dir.join("exclude").join(&slug); // Path to exclusion file
+        info!("Loading exclusion file from {}", filepath.display());
+
+        if let Ok(file) = File::open(&filepath) {
+            let reader = BufReader::new(file);
+            for line in reader.lines().flatten() {
+                let entry = line.trim();
+                if !entry.is_empty() && !entry.starts_with('#') {
+                    if let Ok(g) = Glob::new(entry) {
+                        builder.add(g);
+                    } else {
+                        warn!("Invalid glob pattern '{}' in {}", entry, filepath.display());
+                    }
+                }
+            }
+        } else {
+            warn!("Exclusion file not found: {}", filepath.display());
+        }
+    } else {
+        error!("Failed to resolve maxima data directory");
+    }
+
+    builder
+        .build()
+        .unwrap_or_else(|_| GlobSetBuilder::new().build().unwrap()) // Returns an empty GlobSet on failure
+}

maxima-lib/src/content/manager.rs

@@ -19,6 +19,7 @@ use tokio_util::sync::CancellationToken;
 use crate::{
     content::{
         downloader::{DownloadError, ZipDownloader},
+        exclusion::get_exclusion_list,
         zip::{self, CompressionType, ZipError, ZipFileEntry},
         ContentService,
     },
@@ -28,6 +29,7 @@ use crate::{
         service_layer::ServiceLayerError,
         MaximaEvent,
     },
+    gameinfo::GameInstallInfo,
     util::native::{maxima_dir, NativeError},
 };
 
@@ -38,6 +40,8 @@ pub struct QueuedGame {
     offer_id: String,
     build_id: String,
     path: PathBuf,
+    slug: String,
+    wine_prefix: Option<PathBuf>,
 }
 
 #[derive(Default, Getters, Serialize, Deserialize)]
@@ -124,6 +128,9 @@ impl DownloadQueue {
 
 pub struct GameDownloader {
     offer_id: String,
+    slug: String,
+    path: PathBuf,
+    wine_prefix: Option<PathBuf>,
 
     downloader: Arc<ZipDownloader>,
     entries: Vec<ZipFileEntry>,
@@ -149,8 +156,15 @@ impl GameDownloader {
         let downloader = ZipDownloader::new(&game.offer_id, &url.url(), &game.path).await?;
 
         let mut entries = Vec::new();
+
+        let exclusion_list = get_exclusion_list(game.slug.as_str());
+
         for ele in downloader.manifest().entries() {
             // TODO: Filtering
+            if exclusion_list.is_match(&ele.name()) {
+                // info!("Excluding file from download: {}", ele.name()); Spams if a lot of files are excluded
+                continue;
+            }
             entries.push(ele.clone());
         }
 
@@ -163,7 +177,9 @@ impl GameDownloader {
 
         Ok(GameDownloader {
             offer_id: game.offer_id.to_owned(),
-
+            slug: game.slug.to_owned(),
+            path: game.path.to_owned(),
+            wine_prefix: game.wine_prefix.clone(),
             downloader: Arc::new(downloader),
             entries,
             cancel_token: CancellationToken::new(),
@@ -178,6 +194,8 @@ impl GameDownloader {
         let (downloader_arc, entries, cancel_token, completed_bytes, notify) =
             self.prepare_download_vars();
         let total_count = self.total_count;
+        let slug = self.slug.clone();
+        let game_install_info = GameInstallInfo::new(self.path.clone(), self.wine_prefix.clone());
         tokio::spawn(async move {
             let dl = GameDownloader::start_downloads(
                 total_count,
@@ -186,6 +204,8 @@ impl GameDownloader {
                 cancel_token,
                 completed_bytes,
                 notify,
+                slug,
+                game_install_info,
             )
             .await;
             if let Err(err) = dl {
@@ -219,6 +239,8 @@ impl GameDownloader {
         cancel_token: CancellationToken,
         completed_bytes: Arc<AtomicUsize>,
         notify: Arc<Notify>,
+        slug: String,
+        game_install_info: GameInstallInfo,
     ) -> Result<(), DownloaderError> {
         let mut handles = Vec::with_capacity(total_count);
 
@@ -256,10 +278,17 @@ impl GameDownloader {
 
         let path = downloader_arc.path();
 
-        info!("Files downloaded, running touchup...");
-        let manifest = manifest::read(path.join(MANIFEST_RELATIVE_PATH)).await?;
+        game_install_info.save_to_json(&slug);
+        info!("Files downloaded");
+
+        #[cfg(windows)]
+        // Touchup will be run on linux/mac when first running the game, so we don't need to run it here
+        {
+            info!("Running touchup...");
+            let manifest = manifest::read(path.join(MANIFEST_RELATIVE_PATH)).await?;
+            manifest.run_touchup(path, &slug).await?;
+        }
 
-        manifest.run_touchup(path).await?;
         info!("Installation finished!");
 
         completed_bytes.fetch_add(1, Ordering::SeqCst);

maxima-lib/src/content/mod.rs

@@ -12,6 +12,7 @@ use crate::core::{
 };
 
 pub mod downloader;
+pub mod exclusion;
 pub mod manager;
 pub mod zip;
 pub mod zlib;