from abc import abstractmethod from dataclasses import dataclass from datetime import datetime from enum import IntEnum from logging import getLogger from typing import Optional, List, Tuple from PyQt5.QtCore import QObject, pyqtSignal, QRunnable, QThreadPool, QSettings from legendary.models.game import SaveGameFile, SaveGameStatus, Game, InstalledGame from rare.lgndr.core import LegendaryCore from rare.models.install import UninstallOptionsModel, InstallOptionsModel logger = getLogger("RareGameBase") @dataclass class RareSaveGame: file: SaveGameFile status: SaveGameStatus = SaveGameStatus.NO_SAVE dt_local: Optional[datetime] = None dt_remote: Optional[datetime] = None description: Optional[str] = "" class RareGameBase(QObject): class State(IntEnum): IDLE = 0 RUNNING = 1 DOWNLOADING = 2 VERIFYING = 3 MOVING = 4 UNINSTALLING = 5 SYNCING = 6 class Signals: class Progress(QObject): start = pyqtSignal() update = pyqtSignal(int) finish = pyqtSignal(bool) class Widget(QObject): update = pyqtSignal() class Download(QObject): enqueue = pyqtSignal(str) dequeue = pyqtSignal(str) class Game(QObject): install = pyqtSignal(InstallOptionsModel) installed = pyqtSignal(str) uninstall = pyqtSignal(UninstallOptionsModel) uninstalled = pyqtSignal(str) launched = pyqtSignal(str) finished = pyqtSignal(str) def __init__(self): super(RareGameBase.Signals, self).__init__() self.progress = RareGameBase.Signals.Progress() self.widget = RareGameBase.Signals.Widget() self.download = RareGameBase.Signals.Download() self.game = RareGameBase.Signals.Game() def __del__(self): self.progress.deleteLater() self.widget.deleteLater() self.download.deleteLater() self.game.deleteLater() __slots__ = "igame" def __init__(self, legendary_core: LegendaryCore, game: Game): super(RareGameBase, self).__init__() self.signals = RareGameBase.Signals() self.core = legendary_core self.game: Game = game self._state = RareGameBase.State.IDLE def __del__(self): del self.signals @property def state(self) -> 'RareGameBase.State': return self._state @state.setter def state(self, state: 'RareGameBase.State'): if state != self._state: self._state = state self.signals.widget.update.emit() @property def is_idle(self): return self.state == RareGameBase.State.IDLE @property def app_name(self) -> str: return self.igame.app_name if self.igame is not None else self.game.app_name @property def app_title(self) -> str: return self.igame.title if self.igame is not None else self.game.app_title @property def title(self) -> str: return self.app_title @property @abstractmethod def is_installed(self) -> bool: pass @abstractmethod def set_installed(self, installed: bool) -> None: pass @property @abstractmethod def is_mac(self) -> bool: pass @property @abstractmethod def is_win32(self) -> bool: pass class RareGameSlim(RareGameBase): def __init__(self, legendary_core: LegendaryCore, game: Game): super(RareGameSlim, self).__init__(legendary_core, game) # None if origin or not installed self.igame: Optional[InstalledGame] = self.core.get_installed_game(game.app_name) self.saves: List[RareSaveGame] = [] @property def is_installed(self) -> bool: return True def set_installed(self, installed: bool) -> None: pass @property def is_mac(self) -> bool: """! @brief Property to report if Game has a mac version @return bool """ return "Mac" in self.game.asset_infos.keys() @property def is_win32(self) -> bool: """! @brief Property to report if Game is 32bit game @return bool """ return "Win32" in self.game.asset_infos.keys() @property def auto_sync_saves(self): return self.supports_cloud_saves and QSettings().value( f"{self.app_name}/auto_sync_cloud", QSettings().value("auto_sync_cloud", False, bool), bool ) @property def save_path(self) -> Optional[str]: if self.igame is not None: return self.igame.save_path return None @property def latest_save(self) -> Optional[RareSaveGame]: if self.saves: saves = sorted(self.saves, key=lambda s: s.file.datetime, reverse=True) return saves[0] return None @property def save_game_state(self) -> Tuple[SaveGameStatus, Tuple[Optional[datetime], Optional[datetime]]]: if self.saves and self.save_path: latest = self.latest_save # lk: if the save path wasn't known at startup, dt_local will be None # In that case resolve the save again before returning latest.status, (latest.dt_local, latest.dt_remote) = self.core.check_savegame_state( self.save_path, latest.file ) return latest.status, (latest.dt_local, latest.dt_remote) return SaveGameStatus.NO_SAVE, (None, None) def upload_saves(self, thread=True): status, (dt_local, dt_remote) = self.save_game_state def _upload(): logger.info(f"Uploading save for {self.title}") self.state = RareGameSlim.State.SYNCING self.core.upload_save(self.app_name, self.igame.save_path, dt_local) self.state = RareGameSlim.State.IDLE self.update_saves() if not self.supports_cloud_saves: return if status == SaveGameStatus.NO_SAVE or not dt_local: logger.warning("Can't upload non existing save") return if self.state == RareGameSlim.State.SYNCING: logger.error(f"{self.title} is already syncing") return if thread: worker = QRunnable.create(lambda: _upload()) QThreadPool.globalInstance().start(worker) else: _upload() def download_saves(self, thread=True): status, (dt_local, dt_remote) = self.save_game_state def _download(): logger.info(f"Downloading save for {self.title}") self.state = RareGameSlim.State.SYNCING self.core.download_saves(self.app_name, self.latest_save.file.manifest_name, self.save_path) self.state = RareGameSlim.State.IDLE self.update_saves() if not self.supports_cloud_saves: return if status == SaveGameStatus.NO_SAVE or not dt_remote: logger.error("Can't download non existing save") return if self.state == RareGameSlim.State.SYNCING: logger.error(f"{self.title} is already syncing") return if thread: worker = QRunnable.create(lambda: _download()) QThreadPool.globalInstance().start(worker) else: _download() def load_saves(self, saves: List[SaveGameFile]): """ Use only in a thread """ self.saves.clear() for save in saves: if self.save_path: status, (dt_local, dt_remote) = self.core.check_savegame_state(self.save_path, save) rsave = RareSaveGame(save, status, dt_local, dt_remote) else: rsave = RareSaveGame(save, SaveGameStatus.SAME_AGE, dt_local=None, dt_remote=save.datetime) self.saves.append(rsave) def update_saves(self): """ Use only in a thread """ saves = self.core.get_save_games(self.app_name) self.load_saves(saves) self.signals.widget.update.emit() @property def is_save_up_to_date(self): status, (_, _) = self.save_game_state return (status == SaveGameStatus.SAME_AGE) \ or (status == SaveGameStatus.NO_SAVE) @property def raw_save_path(self) -> str: if self.game.supports_cloud_saves: return self.game.metadata.get("customAttributes", {}).get("CloudSaveFolder", {}).get("value") return "" @property def raw_save_path_mac(self) -> str: if self.game.supports_mac_cloud_saves: return self.game.metadata.get("customAttributes", {}).get('CloudSaveFolder_MAC', {}).get('value') return "" @property def supports_cloud_saves(self): return self.game.supports_cloud_saves or self.game.supports_mac_cloud_saves