Add support for nested paths in custom game installed names

Author: mtkennerly

CHANGELOG.md

@@ -1,5 +1,8 @@
 ## Unreleased
 
+* Added:
+  * A custom game's installed name may now be set to a relative path with multiple folders,
+    rather than only supporting a single bare folder name.
 * Fixed:
   * For home folder roots, Ludusavi skipped any paths containing `<storeUserId>`,
     on the assumption that it shouldn't be applicable to non-store-specific roots.

docs/help/custom-games.md

@@ -12,10 +12,14 @@ and the placeholders defined in the
 If you have a folder name that contains a special glob character,
 you can escape it by wrapping it in brackets (e.g., `[` becomes `[[]`).
 
-Installed names should be a bare folder name only,
+Installed names should be a bare folder name <!-- or relative path --> only<!-- (no absolute paths) -->,
 because Ludusavi will look for this folder in each root.
 Ludusavi automatically looks for the game's own name as well,
 so you only need to specify a custom folder name if it's different.
 For example, if you have an other-type root at `C:\Games`,
 and there's a game called `Some Game` installed at `C:\Games\sg`,
 then you would set the installed name as `sg`.
+<!--
+If you had a bundled game like `C:\Games\trilogy\first-game`,
+then you could set the installed name as `trilogy\first-game`.
+-->

src/path.rs

@@ -859,6 +859,16 @@ impl StrictPath {
         nearest
     }
 
+    pub fn suffix_for(&self, other: &Self) -> Option<String> {
+        self.is_prefix_of(other).then(|| {
+            other
+                .render()
+                .replacen(&self.render(), "", 1)
+                .trim_start_matches(['/', '\\'])
+                .to_string()
+        })
+    }
+
     pub fn glob(&self) -> Vec<StrictPath> {
         self.glob_case_sensitive(Os::HOST.is_case_sensitive())
     }

src/resource/config.rs

@@ -476,6 +476,13 @@ impl Root {
         }
     }
 
+    pub fn games_path(&self) -> StrictPath {
+        match self.store() {
+            Store::Steam => self.path().joined("steamapps/common"),
+            _ => self.path().clone(),
+        }
+    }
+
     pub fn lutris_database(&self) -> Option<&StrictPath> {
         match self {
             Self::Lutris(root) => root.database.as_ref(),

src/scan.rs

@@ -146,6 +146,9 @@ pub fn parse_paths(
         .replace(&format!("{}*", p::STORE_USER_ID), p::STORE_USER_ID);
 
     let install_dir = install_dir.map(|x| x.as_str()).unwrap_or(SKIP);
+    let full_install_dir = full_install_dir
+        .and_then(|x| x.interpret().ok())
+        .unwrap_or_else(|| SKIP.to_string());
 
     let Ok(root_interpreted) = root.path().interpret_unless_skip() else {
         return HashSet::new();
@@ -161,29 +164,7 @@ pub fn parse_paths(
     add_path!(path
         .replace(p::ROOT, &root_interpreted)
         .replace(p::GAME, install_dir)
-        .replace(
-            p::BASE,
-            &match root.store() {
-                Store::Steam => format!("{}/steamapps/common/{}", &root_interpreted, install_dir),
-                Store::Heroic | Store::Legendary | Store::Lutris => full_install_dir
-                    .and_then(|x| x.interpret().ok())
-                    .unwrap_or_else(|| SKIP.to_string()),
-                Store::Ea
-                | Store::Epic
-                | Store::Gog
-                | Store::GogGalaxy
-                | Store::Microsoft
-                | Store::Origin
-                | Store::Prime
-                | Store::Uplay
-                | Store::OtherHome
-                | Store::OtherWine
-                | Store::OtherWindows
-                | Store::OtherLinux
-                | Store::OtherMac
-                | Store::Other => format!("{}/{}", &root_interpreted, install_dir),
-            },
-        )
+        .replace(p::BASE, &full_install_dir)
         .replace(p::HOME, home)
         .replace(p::STORE_USER_ID, "*")
         .replace(p::OS_USER_NAME, &crate::prelude::OS_USERNAME)
@@ -262,10 +243,7 @@ pub fn parse_paths(
                     let path2 = path
                         .replace(p::ROOT, &root_interpreted)
                         .replace(p::GAME, install_dir)
-                        .replace(
-                            p::BASE,
-                            &format!("{}/steamapps/common/{}", &root_interpreted, install_dir),
-                        )
+                        .replace(p::BASE, &full_install_dir)
                         .replace(p::HOME, &format!("{}/users/steamuser", prefix))
                         .replace(p::STORE_USER_ID, "*")
                         .replace(p::OS_USER_NAME, "steamuser")
@@ -575,8 +553,8 @@ pub fn scan_game_for_backup(
 
             if launcher_entries.peek().is_none() {
                 let platform = Os::HOST;
-                let install_dir = None;
                 let full_install_dir = None;
+                let install_dir = None;
 
                 candidates.extend(parse_paths(
                     raw_path,
@@ -593,8 +571,8 @@ pub fn scan_game_for_backup(
                 for launcher_entry in launcher_entries {
                     log::trace!("[{name}] parsing candidates with launcher info: {:?}", &launcher_entry);
                     let platform = launcher_entry.platform.unwrap_or(Os::HOST);
-                    let install_dir = launcher_entry.install_dir.as_ref().and_then(|x| x.leaf());
                     let full_install_dir = launcher_entry.install_dir.as_ref();
+                    let install_dir = full_install_dir.and_then(|x| root.path().suffix_for(x));
 
                     candidates.extend(parse_paths(
                         raw_path,

src/scan/launchers/generic.rs

@@ -6,10 +6,7 @@ use rayon::prelude::*;
 use crate::prelude::INVALID_FILE_CHARS;
 
 use crate::{
-    resource::{
-        config::Root,
-        manifest::{Manifest, Store},
-    },
+    resource::{config::Root, manifest::Manifest},
     scan::launchers::LauncherGame,
 };
 
@@ -55,10 +52,7 @@ fn fuzzy_match(
 pub fn scan(root: &Root, manifest: &Manifest, subjects: &[String]) -> HashMap<String, HashSet<LauncherGame>> {
     log::debug!("ranking installations for root: {:?}", &root);
 
-    let install_parent = match root.store() {
-        Store::Steam => root.path().joined("steamapps/common"),
-        _ => root.path().clone(),
-    };
+    let install_parent = root.games_path();
     let matcher = make_fuzzy_matcher();
 
     let actual_dirs: Vec<_> = install_parent
@@ -83,6 +77,13 @@ pub fn scan(root: &Root, manifest: &Manifest, subjects: &[String]) -> HashMap<St
             let mut best: Option<(i64, &String)> = None;
             'dirs: for expected_dir in expected_install_dirs {
                 log::trace!("[{name}] looking for install dir: {expected_dir}");
+
+                if expected_dir.contains(['/', '\\']) && root.path().joined(expected_dir).is_dir() {
+                    log::trace!("[{name}] using exact nested install dir");
+                    best = Some((i64::MAX, expected_dir));
+                    break 'dirs;
+                }
+
                 let ideal = matcher.fuzzy_match(expected_dir, expected_dir);
                 for actual_dir in &actual_dirs {
                     let score = fuzzy_match(&matcher, expected_dir, actual_dir, ideal);