ludusavi 0.31.0

Game save backup tool
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

pub mod gog;
pub mod legendary;
pub mod nile;
pub mod sideload;

use std::collections::{HashMap, HashSet};

use crate::{path::CommonPath, prelude::StrictPath};

use crate::{
    resource::{config::root, manifest::Os},
    scan::{launchers::LauncherGame, TitleFinder},
};

mod games_config {
    use std::collections::HashMap;

    pub fn path(id: &str) -> String {
        format!("GamesConfig/{id}.json")
    }

    #[derive(serde::Deserialize, Debug)]
    pub struct Data(pub HashMap<String, Game>);

    #[derive(serde::Deserialize, Debug)]
    #[serde(untagged)]
    pub enum Game {
        #[serde(rename_all = "camelCase")]
        Config {
            wine_prefix: String,
            wine_version: Wine,
        },
        IgnoreOther(serde::de::IgnoredAny),
    }

    #[derive(serde::Deserialize, Debug)]
    pub struct Wine {
        #[serde(rename = "type")]
        pub wine_type: String,
    }
}

pub fn scan(
    root: &root::Heroic,
    title_finder: &TitleFinder,
    legendary: Option<&StrictPath>,
) -> HashMap<String, HashSet<LauncherGame>> {
    let mut games = HashMap::<String, HashSet<LauncherGame>>::new();

    for (title, info) in legendary::scan(root, title_finder, legendary) {
        games.entry(title).or_default().extend(info);
    }

    for (title, info) in gog::scan(root, title_finder) {
        games.entry(title).or_default().extend(info);
    }

    for (title, info) in nile::scan(root, title_finder) {
        games.entry(title).or_default().extend(info);
    }

    for (title, info) in sideload::scan(root, title_finder) {
        games.entry(title).or_default().extend(info);
    }

    if Os::HOST == Os::Linux {
        if let Some(normal_home) = CommonPath::Home.get().map(StrictPath::new) {
            if let Some(flatpak_home) = root.flatpak_home() {
                log::debug!("For Flatpak root {root:?}, translating home {normal_home:?} to {flatpak_home:?}");
                return games
                    .into_iter()
                    .map(|(title, mut info)| {
                        let flatpak: HashSet<_> = info
                            .iter()
                            .map(|info| info.replace_in_paths(&normal_home, &flatpak_home))
                            .collect();

                        info.extend(flatpak);

                        (title, info)
                    })
                    .collect();
            }
        }
    }

    games
}

fn find_prefix(
    heroic_path: &StrictPath,
    game_name: &str,
    platform: Option<&str>,
    app_name: &str,
) -> Option<StrictPath> {
    log::trace!(
        "Will try to find prefix for Heroic game: {} (app={}, platform={:?})",
        game_name,
        app_name,
        platform
    );

    let games_config_path = heroic_path.joined(games_config::path(app_name));

    let content = match games_config_path.try_read() {
        Ok(content) => content,
        Err(e) => {
            log::trace!("Failed to read {:?}: {}", &games_config_path, e);
            return None;
        }
    };

    match serde_json::from_str::<games_config::Data>(&content) {
        Ok(games_config_wrapper) => {
            let game_config = games_config_wrapper.0.get(app_name)?;

            match game_config {
                games_config::Game::Config {
                    wine_version,
                    wine_prefix,
                } => match wine_version.wine_type.as_str() {
                    "wine" => {
                        log::trace!(
                            "Found Heroic Wine prefix for {} ({}) -> adding {}",
                            game_name,
                            app_name,
                            wine_prefix
                        );
                        Some(StrictPath::new(wine_prefix.clone()))
                    }

                    "proton" => {
                        // This would usually be `{wine_prefix}/pfx`,
                        // but in at least one case in a Flatpak install,
                        // that was a broken link and the real prefix was just `wine_prefix`.
                        log::trace!(
                            "Found Heroic Proton prefix for {} ({}), adding {}",
                            game_name,
                            app_name,
                            wine_prefix
                        );
                        Some(StrictPath::new(wine_prefix.clone()))
                    }

                    _ => {
                        log::info!(
                            "Found Heroic Windows game {} ({}) with unknown wine_type: {:#?}",
                            game_name,
                            app_name,
                            wine_version.wine_type
                        );
                        None
                    }
                },
                games_config::Game::IgnoreOther(_) => None,
            }
        }
        Err(e) => {
            log::trace!("Failed to parse {:?}: {}", &games_config_path, e);
            None
        }
    }
}