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

pub mod heroic;

/// Returned game information with whatever we could find
#[derive(Clone, Default, Debug)]
pub struct WrapGameInfo {
    pub name: Option<String>,
    pub steam_id: Option<u32>,
    pub gog_id: Option<u64>,
}

impl WrapGameInfo {
    fn is_empty(&self) -> bool {
        let Self { name, steam_id, gog_id } = self;

        name.is_none() && steam_id.is_none() && gog_id.is_none()
    }
}

pub fn infer_game_from_steam() -> Option<WrapGameInfo> {
    for var in ["SteamAppId", "STEAMAPPID"] {
        let Ok(raw) = std::env::var(var) else { continue };
        let Ok(app_id) = raw.parse::<u32>() else { continue };

        log::debug!("Found Steam environment variable: {}={}", var, app_id);

        let result = WrapGameInfo {
            steam_id: Some(app_id),
            ..Default::default()
        };

        return Some(result);
    }

    None
}

pub mod lutris {
    use super::*;

    use crate::path::StrictPath;

    use std::sync::Mutex;

    // TODO: Refactor to avoid shared state.
    static INFERRED_NORMALIZED_TITLE: Mutex<Option<String>> = Mutex::new(None);

    pub struct Metadata {
        pub title: String,
        pub base: Option<StrictPath>,
        pub prefix: Option<StrictPath>,
    }

    pub fn infer() -> Option<WrapGameInfo> {
        let title = if let Ok(title) = std::env::var("GAME_NAME") {
            log::debug!("Found Lutris environment variable: GAME_NAME={}", &title);
            title
        } else if let Ok(title) = std::env::var("game_name") {
            log::debug!("Found Lutris environment variable: game_name={}", &title);
            title
        } else {
            return None;
        };

        let result = WrapGameInfo {
            name: Some(title),
            ..Default::default()
        };

        Some(result)
    }

    pub fn save_normalized_title(title: String) {
        let Ok(mut guard) = INFERRED_NORMALIZED_TITLE.lock() else {
            return;
        };
        *guard = Some(title.clone());
    }

    pub fn infer_metadata() -> Option<Metadata> {
        let guard = INFERRED_NORMALIZED_TITLE.lock().ok()?;
        let title = (*guard).as_ref()?.clone();

        let base = std::env::var("GAME_DIRECTORY").ok();
        let prefix = std::env::var("WINEPREFIX").ok();

        log::debug!(
            "Found Lutris environment variables for inferred game '{}': GAME_DIRECTORY={:?}, WINEPREFIX={:?}",
            &title,
            &base,
            &prefix
        );

        Some(Metadata {
            title,
            base: base.map(StrictPath::new),
            prefix: prefix.map(StrictPath::new),
        })
    }
}