Add files via upload

Author: TheHolyOneZ

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "zgamelib"
-version = "1.2.0"
+version = "1.2.1"
 description = "ZGameLib - Personal Game Library"
 authors = ["TheHolyOneZ"]
 license = "MIT"

src-tauri/Cargo.toml

@@ -36,6 +36,7 @@ pub fn create_game(state: State<DbState>, payload: CreateGamePayload) -> Result<
         date_added: now,
         steam_app_id: payload.steam_app_id,
         epic_app_name: payload.epic_app_name,
+        ubisoft_game_id: payload.ubisoft_game_id,
         tags: vec![],
         sort_order: 0,
         deleted_at: None,
@@ -404,13 +405,14 @@ pub fn get_library_growth(state: State<DbState>) -> Result<Vec<LibraryGrowthEntr
     for (month, platform, cnt) in rows {
         let entry = month_map.entry(month.clone()).or_insert(LibraryGrowthEntry {
             month,
-            steam: 0, epic: 0, gog: 0, custom: 0,
+            steam: 0, epic: 0, gog: 0, custom: 0, ubisoft: 0,
         });
         match platform.as_str() {
-            "steam"  => entry.steam  += cnt,
-            "epic"   => entry.epic   += cnt,
-            "gog"    => entry.gog    += cnt,
-            "custom" => entry.custom += cnt,
+            "steam"   => entry.steam   += cnt,
+            "epic"    => entry.epic    += cnt,
+            "gog"     => entry.gog     += cnt,
+            "custom"  => entry.custom  += cnt,
+            "ubisoft" => entry.ubisoft += cnt,
             _ => {}
         }
     }

src-tauri/src/commands/games.rs

@@ -798,6 +798,114 @@ pub fn launch_epic_game(
     Ok(())
 }
 
+#[tauri::command]
+pub fn launch_ubisoft_game(
+    app: AppHandle,
+    state: State<DbState>,
+    active_pids: State<ActivePids>,
+    game_id: String,
+    game_db_id: String,
+) -> Result<(), String> {
+    let (exe_path, install_dir, game_name, minimize, exclude_idle) = {
+        let conn = state.0.lock().map_err(|e| e.to_string())?;
+        let game = queries::get_game_by_id(&conn, &game_db_id).ok().flatten();
+        let exe = game.as_ref().and_then(|g| g.exe_path.clone());
+        let dir = game.as_ref().and_then(|g| g.install_dir.clone()).or_else(|| {
+            let exe_ref = exe.as_ref()?;
+            let parent = std::path::Path::new(exe_ref).parent()?;
+            if parent.components().count() <= 1 { return None; }
+            Some(parent.to_string_lossy().to_string())
+        });
+        let name = game.as_ref().map(|g| g.name.clone()).unwrap_or_default();
+        let min = queries::get_setting(&conn, "minimize_on_launch")
+            .map(|v| v == "true").unwrap_or(false);
+        let idle = queries::get_setting(&conn, "exclude_idle_time")
+            .map(|v| v != "false").unwrap_or(true);
+        (exe, dir, name, min, idle)
+    };
+
+    if active_pids.game_active.load(Ordering::SeqCst) {
+        let running_name = {
+            let ap = app.state::<ActivePids>();
+            ap.running_game_name.lock().ok()
+                .map(|n| if n.is_empty() { "another game".to_string() } else { n.clone() })
+                .unwrap_or_else(|| "another game".to_string())
+        };
+        let _ = app.emit("game-already-running", &running_name);
+        #[cfg(windows)]
+        show_native_alert("ZGameLib", &format!("\"{}\" is already being tracked.\nClose it first or use Stop Tracking.", running_name));
+        return Err(format!("GAME_ALREADY_RUNNING:{}", running_name));
+    }
+
+    let uri = format!("ubisoft://launch/{}", game_id);
+    open::that(&uri).map_err(|e| format!("Failed to launch Ubisoft game: {}", e))?;
+
+    let now = Utc::now().to_rfc3339();
+    {
+        let conn = state.0.lock().map_err(|e| e.to_string())?;
+        let _ = conn.execute(
+            "UPDATE games SET last_played = ?1 WHERE id = ?2",
+            rusqlite::params![now, game_db_id],
+        );
+    }
+
+    if minimize {
+        let app_min = app.clone();
+        std::thread::spawn(move || {
+            std::thread::sleep(std::time::Duration::from_millis(400));
+            if let Some(win) = app_min.get_webview_window("main") {
+                let _ = win.minimize();
+            }
+        });
+    }
+
+    active_pids.game_active.store(true, Ordering::SeqCst);
+    if let Ok(mut name) = active_pids.running_game_name.lock() {
+        *name = game_name.clone();
+    }
+
+    let app_clone = app.clone();
+    let gid = game_db_id.clone();
+    let pids = active_pids.pids.clone();
+    let started_at = now.clone();
+
+    std::thread::spawn(move || {
+        #[cfg(windows)]
+        {
+            let exe_hint = exe_path.as_ref().and_then(|e| {
+                std::path::Path::new(e).file_name().map(|n| n.to_string_lossy().to_string())
+            });
+            if let Some(dir) = install_dir {
+                track_by_directory(app_clone, gid, started_at, dir, pids, exclude_idle, 300, None, exe_hint);
+            } else if let Some(exe) = exe_path {
+                let exe_name = std::path::Path::new(&exe)
+                    .file_name()
+                    .map(|n| n.to_string_lossy().to_lowercase())
+                    .unwrap_or_default();
+                if !exe_name.is_empty() {
+                    let mut pid: Option<u32> = None;
+                    for _ in 0..180 {
+                        if let Some(p) = find_pid_by_exe_name(&exe_name) {
+                            pid = Some(p);
+                            break;
+                        }
+                        std::thread::sleep(std::time::Duration::from_secs(1));
+                    }
+                    if let Some(p) = pid {
+                        track_by_pid(app_clone, gid, started_at, p, pids, exclude_idle);
+                        return;
+                    }
+                }
+                track_by_timeout(app_clone, gid, started_at);
+            } else {
+                track_by_timeout(app_clone, gid, started_at);
+            }
+        }
+    });
+
+    Ok(())
+}
+
 #[tauri::command]
 pub fn open_game_folder(state: State<DbState>, id: String) -> Result<(), String> {
     let conn = state.0.lock().map_err(|e| e.to_string())?;

src-tauri/src/commands/launcher.rs

@@ -506,6 +506,7 @@ fn scan_steam_games_inner(app: AppHandle, db: std::sync::Arc<std::sync::Mutex<ru
             date_added: now.clone(),
             steam_app_id: Some(entry.app_id),
             epic_app_name: None,
+            ubisoft_game_id: None,
             tags: vec![],
             sort_order: 0,
             deleted_at: None,
@@ -648,6 +649,7 @@ fn scan_epic_games_inner(app: AppHandle, db: std::sync::Arc<std::sync::Mutex<rus
             date_added: now.clone(),
             steam_app_id: None,
             epic_app_name: Some(entry.app_name),
+            ubisoft_game_id: None,
             tags: vec![],
             sort_order: 0,
             deleted_at: None,
@@ -799,7 +801,7 @@ fn scan_gog_games_inner(app: AppHandle, db: std::sync::Arc<std::sync::Mutex<rusq
             status: "none".to_string(),
             is_favorite: false, playtime_mins: 0,
             last_played: None, date_added: now.clone(),
-            steam_app_id: None, epic_app_name: None,
+            steam_app_id: None, epic_app_name: None, ubisoft_game_id: None,
             tags: vec![], sort_order: 0,
             deleted_at: None, is_pinned: false,
             custom_fields: std::collections::HashMap::new(),
@@ -881,6 +883,153 @@ pub fn get_game_screenshots(steam_app_id: String) -> Result<Vec<String>, String>
     Ok(shots.into_iter().map(|p| p.to_string_lossy().to_string()).collect())
 }
 
+#[cfg(windows)]
+fn get_ubisoft_games_from_registry() -> Vec<(String, String, String)> {
+    use winreg::enums::{HKEY_LOCAL_MACHINE, KEY_READ};
+    use winreg::RegKey;
+    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
+    let mut games = vec![];
+    let installs_paths = [
+        "SOFTWARE\\WOW6432Node\\Ubisoft\\Launcher\\Installs",
+        "SOFTWARE\\Ubisoft\\Launcher\\Installs",
+    ];
+    for installs_path in &installs_paths {
+        if let Ok(installs_key) = hklm.open_subkey_with_flags(installs_path, KEY_READ) {
+            for game_id in installs_key.enum_keys().flatten() {
+                if let Ok(sub) = installs_key.open_subkey_with_flags(&game_id, KEY_READ) {
+                    let install_dir: String = sub.get_value("InstallDir").unwrap_or_default();
+                    if install_dir.is_empty() { continue; }
+                    let name = hklm
+                        .open_subkey_with_flags(
+                            &format!("SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Uplay Install {}", game_id),
+                            KEY_READ,
+                        )
+                        .or_else(|_| hklm.open_subkey_with_flags(
+                            &format!("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Uplay Install {}", game_id),
+                            KEY_READ,
+                        ))
+                        .ok()
+                        .and_then(|k| k.get_value::<String, _>("DisplayName").ok())
+                        .unwrap_or_default();
+                    if name.is_empty() { continue; }
+                    games.push((game_id, name, install_dir));
+                }
+            }
+            if !games.is_empty() { break; }
+        }
+    }
+    games
+}
+
+#[cfg(not(windows))]
+fn get_ubisoft_games_from_registry() -> Vec<(String, String, String)> { vec![] }
+
+#[tauri::command]
+pub async fn scan_ubisoft_games(app: AppHandle, state: State<'_, DbState>) -> Result<ScanResult, String> {
+    let db = state.0.clone();
+    let app2 = app.clone();
+    tokio::task::spawn_blocking(move || scan_ubisoft_games_inner(app2, db))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn scan_ubisoft_games_inner(app: AppHandle, db: std::sync::Arc<std::sync::Mutex<rusqlite::Connection>>) -> Result<ScanResult, String> {
+    let raw = get_ubisoft_games_from_registry();
+    let total = raw.len();
+    log(&app, "info", &format!("Ubisoft Connect: found {} game(s) in registry", total));
+
+    struct UbisoftEntry { game_id: String, name: String, exe_path: Option<String>, install_dir: String, cover: Option<String> }
+    let mut entries = Vec::with_capacity(total);
+
+    for (game_id, name, install_dir) in raw {
+        log(&app, "info", &format!("--- [{}] {}", game_id, name));
+        let exe_path = find_steam_game_exe(&install_dir, &name);
+        match &exe_path {
+            Some(p) => log(&app, "ok", &format!("  exe: {}", p)),
+            None => log(&app, "warn", "  exe: not found"),
+        }
+        let cover = if let Some(local) = find_cover_in_dir_internal(&install_dir) {
+            log(&app, "ok", &format!("  cover: local ({})", local));
+            Some(local)
+        } else {
+            log(&app, "info", &format!("  searching Steam CDN for \"{}\"...", name));
+            let sc = search_steam_cover_for_name(&name, &app);
+            match &sc {
+                Some(_) => log(&app, "ok", "  cover: Steam CDN ✓"),
+                None => log(&app, "warn", "  cover: not found"),
+            }
+            sc
+        };
+        entries.push(UbisoftEntry { game_id, name, exe_path, install_dir, cover });
+    }
+
+    let conn = db.lock().map_err(|e| e.to_string())?;
+    conn.execute_batch("BEGIN").map_err(|e| e.to_string())?;
+    let now = chrono::Utc::now().to_rfc3339();
+    let mut added = 0;
+    let mut skipped = 0;
+
+    let mut ubi_stmt = conn.prepare(
+        "SELECT ubisoft_game_id, id, cover_path FROM games WHERE ubisoft_game_id IS NOT NULL AND deleted_at IS NULL"
+    ).map_err(|e| e.to_string())?;
+    let ubi_existing: std::collections::HashMap<String, (String, Option<String>)> =
+        ubi_stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?, r.get::<_, Option<String>>(2)?)))
+            .map_err(|e| e.to_string())?
+            .filter_map(|r| r.ok())
+            .map(|(gid, id, cover)| (gid, (id, cover)))
+            .collect();
+    drop(ubi_stmt);
+
+    for entry in entries {
+        if let Some((existing_id, existing_cover)) = ubi_existing.get(&entry.game_id) {
+            let existing_id = existing_id.clone();
+            if existing_cover.is_none() {
+                if let Some(ref cover) = entry.cover {
+                    let _ = crate::db::queries::update_cover_path(&conn, &existing_id, cover);
+                }
+            }
+            skipped += 1;
+            continue;
+        }
+        let game = Game {
+            id: Uuid::new_v4().to_string(),
+            name: entry.name,
+            platform: "ubisoft".to_string(),
+            exe_path: entry.exe_path,
+            install_dir: Some(entry.install_dir),
+            cover_path: entry.cover,
+            description: None,
+            rating: None,
+            status: "none".to_string(),
+            is_favorite: false,
+            playtime_mins: 0,
+            last_played: None,
+            date_added: now.clone(),
+            steam_app_id: None,
+            epic_app_name: None,
+            ubisoft_game_id: Some(entry.game_id),
+            tags: vec![],
+            sort_order: 0,
+            deleted_at: None,
+            is_pinned: false,
+            custom_fields: std::collections::HashMap::new(),
+            hltb_main_mins: None,
+            hltb_extra_mins: None,
+            genre: None,
+            developer: None,
+            publisher: None,
+            release_year: None,
+            igdb_skipped: false,
+            not_installed: false,
+        };
+        if queries::insert_game(&conn, &game).is_ok() { added += 1; }
+    }
+
+    conn.execute_batch("COMMIT").map_err(|e| e.to_string())?;
+    log(&app, "ok", &format!("Ubisoft scan done: {} added, {} skipped", added, skipped));
+    Ok(ScanResult { added, skipped, total })
+}
+
 #[tauri::command]
 pub async fn scan_all_games(app: AppHandle, state: State<'_, DbState>) -> Result<ScanResult, String> {
     if SCAN_RUNNING.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst).is_err() {
@@ -895,17 +1044,19 @@ pub async fn scan_all_games(app: AppHandle, state: State<'_, DbState>) -> Result
         log(&app2, "info", "=== Scanning Epic ===");
         let epic = scan_epic_games_inner(app2.clone(), db.clone()).unwrap_or(empty.clone());
         log(&app2, "info", "=== Scanning GOG ===");
-        let gog = scan_gog_games_inner(app2.clone(), db).unwrap_or(empty);
+        let gog = scan_gog_games_inner(app2.clone(), db.clone()).unwrap_or(empty.clone());
+        log(&app2, "info", "=== Scanning Ubisoft Connect ===");
+        let ubi = scan_ubisoft_games_inner(app2.clone(), db).unwrap_or(empty);
         log(&app2, "ok", &format!(
             "=== All done: {} added, {} skipped, {} total ===",
-            steam.added + epic.added + gog.added,
-            steam.skipped + epic.skipped + gog.skipped,
-            steam.total + epic.total + gog.total,
+            steam.added + epic.added + gog.added + ubi.added,
+            steam.skipped + epic.skipped + gog.skipped + ubi.skipped,
+            steam.total + epic.total + gog.total + ubi.total,
         ));
         Ok(ScanResult {
-            added: steam.added + epic.added + gog.added,
-            skipped: steam.skipped + epic.skipped + gog.skipped,
-            total: steam.total + epic.total + gog.total,
+            added: steam.added + epic.added + gog.added + ubi.added,
+            skipped: steam.skipped + epic.skipped + gog.skipped + ubi.skipped,
+            total: steam.total + epic.total + gog.total + ubi.total,
         })
     })
     .await
@@ -1082,6 +1233,7 @@ fn scan_folder_for_games_inner(app: AppHandle, db: std::sync::Arc<std::sync::Mut
             date_added: now.clone(),
             steam_app_id: None,
             epic_app_name: None,
+            ubisoft_game_id: None,
             tags: vec![],
             sort_order: 0,
             deleted_at: None,

src-tauri/src/commands/scanner.rs

@@ -144,7 +144,7 @@ pub fn import_library(state: State<DbState>, path: String) -> Result<ImportResul
     let mut added = 0;
     let mut skipped = 0;
 
-    const VALID_PLATFORMS: &[&str] = &["steam", "epic", "gog", "custom"];
+    const VALID_PLATFORMS: &[&str] = &["steam", "epic", "gog", "custom", "ubisoft"];
 
     for mut game in games {
         if game.name.is_empty() || game.name.len() > 255 { skipped += 1; continue; }
@@ -588,6 +588,7 @@ pub fn pull_uninstalled_steam_games(state: State<DbState>, api_key: String, stea
             date_added: now.clone(),
             steam_app_id: Some(appid),
             epic_app_name: None,
+            ubisoft_game_id: None,
             tags: vec![],
             sort_order: 0,
             deleted_at: None,