steamlocate 1.1.0

Rust Crate for locating Steam game installation directories (and Steam itself!)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use std::{
    fs,
    path::{Path, PathBuf},
};

use keyvalues_parser::Vdf;

/// An instance which contains all the Steam library folders installed on the file system.
/// Example:
/// ```rust
/// # use std::{vec, path::PathBuf};
/// # use steamlocate::{SteamDir, LibraryFolders};
/// let mut steamdir: SteamDir = SteamDir::locate().unwrap();
/// let libraryfolders: &LibraryFolders = steamdir.libraryfolders();
/// let paths: &Vec<PathBuf> = &libraryfolders.paths;
/// println!("{:#?}", paths);
/// ```
/// ```ignore
/// {
///		"C:\\Program Files (x86)\\Steam\\steamapps",
///		"D:\\Steam\\steamapps",
///		"E:\\Steam\\steamapps",
///		"F:\\Steam\\steamapps",
///		...
///	}
/// ```
#[derive(Default, Clone, Debug)]
pub struct LibraryFolders {
    /// A `Vec<PathBuf>` of Steam library folder paths.
    ///
    /// This will always include the Steam installation directory's `SteamApps` folder.
    pub paths: Vec<PathBuf>,
    pub(crate) discovered: bool,
}

impl LibraryFolders {
    /// Discovers all the steam libraries from `libraryfolders.vdf`
    ///
    /// We want all the library paths from `libraryfolders.vdf` which has the following structure
    ///
    /// ```vdf
    /// "libraryfolders"
    /// {
    ///     ...
    ///     "0"
    ///     {
    ///         "path"    "/path/to/first/library"
    ///         ...
    ///     }
    ///     "1"
    ///     {
    ///         "path"    "/path/to/second/library"
    ///         ...
    ///     }
    ///     ...
    /// }
    /// ```
    pub(crate) fn discover(&mut self, path: &Path) {
        let _ = self._discover(path);
    }

    fn _discover(&mut self, path: &Path) -> Option<()> {
        let steamapps = path.join("steamapps");
        self.paths.push(steamapps.clone());

        let libraryfolders_vdf_path = steamapps.join("libraryfolders.vdf");
        if libraryfolders_vdf_path.is_file() {
            let vdf_text = fs::read_to_string(&libraryfolders_vdf_path).ok()?;
            let value = Vdf::parse(&vdf_text).ok()?.value;
            let obj = value.get_obj()?;

            let library_folders: Vec<_> = obj
                .iter()
                .filter(|(key, values)| key.parse::<u32>().is_ok() && values.len() == 1)
                .filter_map(|(_, values)| {
                    let library_folder_string = values
                        .get(0)?
                        .get_obj()?
                        .get("path")?
                        .get(0)?
                        .get_str()?
                        .to_string();
                    let library_folder = PathBuf::from(library_folder_string).join("steamapps");
                    Some(library_folder)
                })
                .collect();

            self.paths = library_folders;
        }

        self.discovered = true;

        Some(())
    }
}