`03d6277`

launch games via proton in wanda prefix

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 03d6277cafe24a14dbe066cff4d3bb04b6d4f74b
Parents: 36648f4
Tree: c093aef

4 changed files

Status	File	+	-
M	`crates/wanda-core/src/launcher.rs`	49	122
M	`crates/wanda-core/src/prefix/builder.rs`	5	2
M	`crates/wanda-core/src/steam/proton.rs`	24	7
M	`crates/wanda-core/src/wemod/installer.rs`	3	7

crates/wanda-core/src/launcher.rsmodified

  //! Game launching with WeMod
  //!
  //! Handles launching Steam games alongside WeMod through Proton.
++//!
++//! Key insight: WeMod and the game MUST run in the same Wine prefix
++//! for WeMod to be able to hook into the game process. We achieve this by
++//! running both from wanda's prefix (which has .NET and WeMod installed).
  use crate::error::{Result, WandaError};
  use crate::prefix::WandaPrefix;
  use std::process::Stdio;
  use std::time::Duration;
  use tokio::process::{Child, Command};
--use tracing::{debug, info, warn};
++use tracing::info;
  /// Configuration for launching a game
  #[derive(Debug, Clone)]
      pub fn is_running(&mut self) -> bool {
          if let Some(ref mut wemod) = self.wemod_process {
              match wemod.try_wait() {
--                Ok(Some(_)) => return false, // WeMod exited
++                Ok(Some(_)) => return false,
--                Ok(None) => return true,     // Still running
++                Ok(None) => return true,
                  Err(_) => return false,
+             }
+         }
  /// Game launcher that coordinates WeMod and game startup
  pub struct GameLauncher<'a> {
--    /// Steam installation
      steam: &'a SteamInstallation,
--    /// WANDA prefix with WeMod
      prefix: &'a WandaPrefix,
--    /// Proton version to use
      proton: &'a ProtonVersion,
+ }
          prefix: &'a WandaPrefix,
          proton: &'a ProtonVersion,
      ) -> Self {
--        Self {
++        Self { steam, prefix, proton }
--            steam,
--            prefix,
--            proton,
--        }
+     }
      /// Build environment variables for launching
--    fn build_env(&self, game: &SteamApp) -> HashMap<String, String> {
++    fn build_env(&self) -> HashMap<String, String> {
          let mut env = HashMap::new();
--        // Wine prefix (WANDA's prefix for WeMod)
          env.insert(
              "WINEPREFIX".to_string(),
--            self.prefix.path.to_string_lossy().to_string(),
++            self.prefix.pfx_path().to_string_lossy().to_string(),
          );
--
--        // Steam compatibility data path (for the game's own prefix if needed)
--        if let Some(ref compat_path) = game.compat_data_path {
          env.insert(
              "STEAM_COMPAT_DATA_PATH".to_string(),
--                compat_path.to_string_lossy().to_string(),
++            self.prefix.path.to_string_lossy().to_string(),
          );
--        }
--
--        // Steam client install path
          env.insert(
              "STEAM_COMPAT_CLIENT_INSTALL_PATH".to_string(),
              self.steam.root_path.to_string_lossy().to_string(),
          );
--
--        // Proton flags that may help stability
          env.insert("PROTON_NO_ESYNC".to_string(), "1".to_string());
          env.insert("PROTON_NO_FSYNC".to_string(), "1".to_string());
--
--        // Reduce Wine debug noise
          env.insert("WINEDEBUG".to_string(), "-all".to_string());
          env
          let game = self
              .steam
              .find_game(config.app_id)
--            .ok_or(WandaError::GameNotFound {
++            .ok_or(WandaError::GameNotFound { app_id: config.app_id })?;
--                app_id: config.app_id,
--            })?;
          info!(
              "Launching {} (AppID: {}) {}",
              game.name,
              game.app_id,
--            if config.with_wemod {
++            if config.with_wemod { "with WeMod" } else { "without WeMod" }
--                "with WeMod"
--            } else {
--                "without WeMod"
--            }
          );
--        let mut env = self.build_env(game);
++        info!("Using WANDA prefix: {}", self.prefix.path.display());
++
++        // Kill stale wineservers to avoid conflicts
++        info!("Cleaning up stale wineservers...");
++        let _ = Command::new("pkill").args(["-9", "wineserver"]).output().await;
++        tokio::time::sleep(Duration::from_secs(1)).await;
++
++        let mut env = self.build_env();
++        env.insert("SteamAppId".to_string(), config.app_id.to_string());
++        env.insert("SteamGameId".to_string(), config.app_id.to_string());
          env.extend(config.extra_env);
          let wine = self.wine_exe();
          let mut wemod_process = None;
--        // Start WeMod first if requested
          if config.with_wemod {
              let wemod_exe = self.prefix.wemod_exe();
              if !wemod_exe.exists() {
+             }
              info!("Starting WeMod...");
++            info!("WeMod path: {}", wemod_exe.display());
++
              let child = Command::new(&wine)
                  .arg(&wemod_exe)
++                .arg("--no-sandbox")
                  .envs(&env)
--                .stdout(Stdio::null())
++                .stdout(Stdio::inherit())
--                .stderr(Stdio::null())
++                .stderr(Stdio::inherit())
                  .spawn()
                  .map_err(|e| WandaError::LaunchFailed {
                      reason: format!("Failed to start WeMod: {}", e),
              wemod_process = Some(child);
--            // Wait for WeMod to initialize
++            info!("Waiting {} seconds for WeMod to initialize...", config.wemod_delay);
--            info!(
--                "Waiting {} seconds for WeMod to initialize...",
--                config.wemod_delay
--            );
              tokio::time::sleep(Duration::from_secs(config.wemod_delay)).await;
+         }
--        // Launch the game via Steam
++        info!("Launching game via Proton...");
--        // Using steam:// URL protocol ensures Steam handles Proton setup correctly
++        self.launch_game_via_proton(&game, &config.extra_args, &env).await?;
--        info!("Launching game via Steam...");
--        self.launch_via_steam(config.app_id).await?;
          Ok(LaunchHandle {
              wemod_process,
          })
+     }
--    /// Launch a game via Steam's URL protocol
++    /// Launch game via Proton
--    async fn launch_via_steam(&self, app_id: u32) -> Result<()> {
++    async fn launch_game_via_proton(
--        // Use xdg-open to launch via steam:// protocol
++        &self,
--        // This ensures Steam handles all the Proton setup correctly
++        game: &SteamApp,
--        let steam_url = format!("steam://rungameid/{}", app_id);
++        args: &[String],
--
++        env: &HashMap<String, String>,
--        let status = Command::new("xdg-open")
++    ) -> Result<()> {
--            .arg(&steam_url)
--            .stdout(Stdio::null())
--            .stderr(Stdio::null())
--            .status()
--            .await
--            .map_err(|e| WandaError::LaunchFailed {
--                reason: format!("Failed to launch Steam URL: {}", e),
--            })?;
--
--        if !status.success() {
--            // Try alternative: steam command directly
--            let status = Command::new("steam")
--                .arg(&steam_url)
--                .stdout(Stdio::null())
--                .stderr(Stdio::null())
--                .status()
--                .await
--                .map_err(|e| WandaError::LaunchFailed {
--                    reason: format!("Failed to launch via steam command: {}", e),
--                })?;
--
--            if !status.success() {
--                warn!("Steam launch returned non-zero, game may still start");
--            }
--        }
--
--        debug!("Game launch initiated via Steam");
--        Ok(())
--    }
--
--    /// Launch a game directly via Proton (without Steam)
--    /// This is an alternative method that gives more control
--    #[allow(dead_code)]
--    async fn launch_directly(&self, game: &SteamApp, args: &[String]) -> Result<Child> {
          let proton_exe = self.proton.proton_exe();
--
          if !proton_exe.exists() {
              return Err(WandaError::ProtonNotFound);
+         }
--        // Find the game executable
          let game_exe = self.find_game_executable(game)?;
--
++        info!("Game executable: {}", game_exe.display());
--        let mut env = self.build_env(game);
--
--        // Set up Proton environment
--        env.insert("STEAM_COMPAT_DATA_PATH".to_string(),
--            game.compat_data_path
--                .as_ref()
--                .map(|p| p.to_string_lossy().to_string())
--                .unwrap_or_else(|| {
--                    self.steam.root_path
--                        .join("steamapps/compatdata")
--                        .join(game.app_id.to_string())
--                        .to_string_lossy()
--                        .to_string()
--                })
--        );
          let mut cmd = Command::new(&proton_exe);
--        cmd.arg("run").arg(&game_exe);
++        cmd.arg("run").arg(&game_exe).args(args).envs(env);
--        cmd.args(args);
++        cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit());
--        cmd.envs(&env);
--        cmd.stdout(Stdio::null());
--        cmd.stderr(Stdio::null());
--        let child = cmd.spawn().map_err(|e| WandaError::LaunchFailed {
++        info!("Running: {} run {}", proton_exe.display(), game_exe.display());
++
++        cmd.spawn().map_err(|e| WandaError::LaunchFailed {
              reason: format!("Failed to start game: {}", e),
          })?;
--        Ok(child)
++        Ok(())
+     }
--    /// Try to find the main executable for a game
++    /// Find the main executable for a game
      fn find_game_executable(&self, game: &SteamApp) -> Result<PathBuf> {
          let install_path = &game.install_path;
          if !install_path.exists() {
--            return Err(WandaError::GameNotFound {
++            return Err(WandaError::GameNotFound { app_id: game.app_id });
--                app_id: game.app_id,
--            });
+         }
--        // Common executable patterns
          let patterns = [
              format!("{}.exe", game.install_dir),
              "game.exe".to_string(),
              "launcher.exe".to_string(),
          ];
--        // Try to find a matching executable
          for pattern in &patterns {
              let exe_path = install_path.join(pattern);
              if exe_path.exists() {
+             }
+         }
--        // Walk the directory looking for .exe files
          for entry in walkdir::WalkDir::new(install_path)
              .max_depth(2)
              .into_iter()
              if let Some(ext) = path.extension() {
                  if ext == "exe" {
                      let name = path.file_name().unwrap_or_default().to_string_lossy();
--                    // Skip common non-game executables
                      if !name.to_lowercase().contains("unins")
                          && !name.to_lowercase().contains("redist")
                          && !name.to_lowercase().contains("setup")

crates/wanda-core/src/prefix/builder.rsmodified

      async fn install_dependencies(&self) -> Result<()> {
          info!("Installing additional dependencies...");
--        // Install common dependencies WeMod might need
++        // Install common dependencies WeMod needs
--        let deps = ["vcrun2019", "corefonts"];
++        // - vcrun2019: Visual C++ runtime
++        // - corefonts: Windows fonts
++        // - winhttp/wininet: Network components for WeMod authentication
++        let deps = ["vcrun2019", "corefonts", "winhttp", "wininet"];
          for dep in deps {
              info!("Installing {}...", dep);

crates/wanda-core/src/steam/proton.rsmodified

          is_ge: bool,
          is_experimental: bool,
      ) -> ProtonCompatibility {
--        // GE-Proton 8+ is recommended for WeMod
++        // Proton Experimental is recommended for WeMod
--        if is_ge && version.0 >= 8 {
++        // GE-Proton 10.x has wow64 mode issues that cause WeMod to crash
++        if is_experimental {
              return ProtonCompatibility::Recommended;
+         }
--        // GE-Proton 7.x should work
++        // GE-Proton 9.x and below should work (before wow64 mode)
--        if is_ge && version.0 >= 7 {
++        if is_ge && version.0 >= 8 && version.0 <= 9 {
              return ProtonCompatibility::Supported;
+         }
--        // Proton Experimental might work
++        // GE-Proton 10.x has known wow64 issues with WeMod
--        if is_experimental {
++        if is_ge && version.0 >= 10 {
              return ProtonCompatibility::Experimental;
+         }
++        // GE-Proton 7.x might work
++        if is_ge && version.0 >= 7 {
++            return ProtonCompatibility::Supported;
++        }
++
          // Standard Proton 8+ should work
          if version.0 >= 8 {
              return ProtonCompatibility::Supported;
      #[test]
      fn test_compatibility() {
++        // Proton Experimental is now recommended (GE-Proton 10.x has wow64 issues)
          let compat =
--            ProtonManager::determine_compatibility("GE-Proton9-5", (9, 5, 0), true, false);
++            ProtonManager::determine_compatibility("Proton - Experimental", (0, 0, 0), false, true);
          assert_eq!(compat, ProtonCompatibility::Recommended);
++        // GE-Proton 9.x is supported (before wow64 issues)
++        let compat =
++            ProtonManager::determine_compatibility("GE-Proton9-5", (9, 5, 0), true, false);
++        assert_eq!(compat, ProtonCompatibility::Supported);
++
++        // GE-Proton 10.x is experimental (wow64 issues)
++        let compat =
++            ProtonManager::determine_compatibility("GE-Proton10-28", (10, 28, 0), true, false);
++        assert_eq!(compat, ProtonCompatibility::Experimental);
++
          let compat =
              ProtonManager::determine_compatibility("Proton 6.0", (6, 0, 0), false, false);
          assert_eq!(compat, ProtonCompatibility::Unsupported);

crates/wanda-core/src/wemod/installer.rsmodified

          info!("Starting WeMod from: {}", wemod_exe.display());
          info!("Using wine: {}", wine);
--        // Run WeMod with required flags for Wine/Proton compatibility
++        // Run WeMod with minimal flags for Wine/Proton compatibility
--        // These Electron flags are necessary for proper rendering under Wine
++        // Only --no-sandbox is required; additional GPU flags can cause issues
          let child = Command::new(&wine)
              .arg(&wemod_exe)
--            .arg("--no-sandbox")              // Required for Wine
++            .arg("--no-sandbox")  // Required for Electron under Wine
--            .arg("--disable-gpu")             // Disable GPU acceleration
--            .arg("--disable-gpu-compositing") // Disable GPU compositing
--            .arg("--disable-software-rasterizer") // Force hardware path (paradoxically helps)
--            .arg("--in-process-gpu")          // Run GPU in main process
              .envs(&env)
              .stdout(Stdio::inherit())
              .stderr(Stdio::inherit())