updated env variables and fix cassette beasts again

Author: TsunaMoo

games/game_cassettebeasts.py

@@ -1,14 +1,30 @@
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from functools import cached_property
+from io import BytesIO
+from typing import Any, Optional
+from pathlib import Path
+import json
+import math
 import os
 import shutil
-import mobase
+import struct
+import zlib
 
-from pathlib import Path
-from functools import cached_property
+import mobase
+from PyQt6.QtCore import QDateTime, QDir, QFile, QFileInfo
 
+from ..basic_features import BasicLocalSavegames
+from ..basic_features.basic_save_game_info import (BasicGameSaveGame,BasicGameSaveGameInfo)
 from ..basic_game import BasicGame
 
-from PyQt6.QtCore import QDir, QFileInfo
 
+def json_get_me(value: Any, path: Sequence[str | int], /, default: Any) -> Any:
+    for part in path:
+        if type(part) not in (str, int) or type(value) not in (dict, list):
+            return default
+        value = value[part]
+    return value
 
 class CassetteBeastsModDataChecker(mobase.ModDataChecker):
     def __init__(self, organizer: mobase.IOrganizer):
@@ -47,26 +63,125 @@ def fix(self, filetree: mobase.IFileTree) -> mobase.IFileTree:
             return None
         return filetree
 
+class CassetteBlock:
+    def __init__(self):
+        compressed_size: str = "(unknown)"
+        data: str = "(unknown)"
+
+class CassetteBeastsSaveGame(BasicGameSaveGame):
+    def __init__(self, filepath: Path):
+        super().__init__(filepath)
+        self.name: str = "(unknown)"
+        self.cheated: str = "(unknown)"
+        self.lastsave: str = "(unknown)"
+        self.elapsed: str = "(unknown)"
+        # This doesn't state wether the game would load it,
+        # only if the data was properly parsed.
+        self.errorMessage: str = ""
+
+        save_data = None
+        try:
+            info = bytearray()
+            data = bytes()
+            with open(filepath, 'rb') as infile:
+                infile.read(4)
+
+                compression_mode, blocksize, raw_size = struct.unpack("III", infile.read(12))
+
+                num_blocks = math.ceil(raw_size / blocksize)
+
+                blocks = []
+
+                for _bnum in range(num_blocks):
+                    block = CassetteBlock()
+                    block.compressed_size = struct.unpack("I", infile.read(4))[0]
+                    blocks.append(block)
+
+                for block in blocks:
+                    block.data = infile.read(block.compressed_size)
+
+                infile.read(4)
+                infile.close()
+            for block in blocks:
+                data = zlib.decompress(block.data, wbits=40, bufsize=blocksize)
+                info = info + data
+            save_data = json.load(BytesIO(info))
+        except (OSError, struct.error, ValueError) as err:
+            s = str(err)
+            self.errorMessage = ('{0}: {1}' if s else '{0}').format(
+                err.__class__.__name__, s
+            )
+            return
+        x = json_get_me(save_data, ["party", "player", "custom", "name"], None)
+        if type(x) is str:
+            self.name = x
+        x = json_get_me(save_data, ["saved_datetime"], None)
+        if type(x) in (int, float):
+            try:
+                dt = datetime.fromtimestamp(float(x))
+            except OSError:
+                pass
+            else:
+                self.lastsave = "{0:d}-{1:02d}-{2:02d} at {3:02d}:{4:02d}:{5:02d}".format(
+                    dt.year, dt.month, dt.day,
+                    dt.hour, dt.minute, dt.second
+                )
+        x = json_get_me(save_data, ["play_time"], None)
+        if type(x) in (int, float):
+            a = [ 0, 0, 0, int(x * 10) ]
+            a[2:4] = divmod(a[3], 10)
+            a[1:3] = divmod(a[2], 60)
+            a[0:2] = divmod(a[1], 60)
+            self.elapsed = "{0:02d}:{1:02d}:{2:02d}.{3:01d}".format(*a)
+        x = json_get_me(save_data, ["has_cheated"], None)
+        if type(x) is bool:
+            self.cheated = "Yes" if x else "No"
+
+    def getName(self) -> str:
+        return self.name
+
+    def getCheated(self) -> str:
+        return self.cheated
+
+    def getLastSaved(self) -> str:
+        return self.lastsave
+
+    def getPlayTime(self) -> str:
+        return self.elapsed
+
+def getMetadata(p: Path, save: mobase.ISaveGame) -> Mapping[str, str]:
+    if not save.errorMessage:
+        return {
+            "Character": save.getName(),
+            "Last Saved": save.getLastSaved(),
+            "Play Time": save.getPlayTime(),
+            "Cheated": save.getCheated()
+        }
+    return {
+        "Error loading file:": save.errorMessage
+    }
 
 class CassetteBeastsGame(BasicGame):
-    appdataenv = os.getenv("APPDATA")
-
     Name = "Cassette Beasts Support Plugin"
     Author = "modworkshop"
     Version = "1"
     GameName = "Cassette Beasts"
     GameShortName = "cassette-beasts"
     GameSteamId = 1321440
     GameBinary = "CassetteBeasts.exe"
-    GameDataPath = appdataenv + "/CassetteBeasts/mods"
-    GameDocumentsDirectory = appdataenv + "/CassetteBeasts"
-    GameSavesDirectory = '%GAME_DOCUMENTS%'
+    GameDataPath = "%USERPROFILE%/AppData/Roaming/CassetteBeasts/mods"
+    GameDocumentsDirectory = "%USERPROFILE%/AppData/Roaming/CassetteBeasts"
+    GameSavesDirectory = "%GAME_DOCUMENTS%"
     GameSaveExtension = "gcpf"
 
     def init(self, organizer: mobase.IOrganizer) -> bool:
         super().init(organizer)
         self.dataChecker = CassetteBeastsModDataChecker(organizer)
         self._register_feature(self.dataChecker)
+        self._register_feature(BasicLocalSavegames(self))
+        self._register_feature(
+            BasicGameSaveGameInfo(None, getMetadata)
+        )
         return True
 
     def executables(self):
@@ -81,6 +196,13 @@ def executables(self):
             ),
         ]
 
+    def listSaves(self, folder: QDir) -> list[mobase.ISaveGame]:
+        ext = self._mappings.savegameExtension.get()
+        return [
+            CassetteBeastsSaveGame(path)
+            for path in Path(folder.absolutePath()).glob(f"*.{ext}")
+        ]
+
     @cached_property
     def _base_dlls(self) -> set[str]:
         base_dir = Path(self.gameDirectory().absolutePath())

games/game_ovkwalkingdead.py

@@ -179,7 +179,7 @@ class OTWDGame(BasicGame):
     GameDataUE4SSMods = "Binaries/Win64/Mods"
     GameDataPakMods = "Content/Paks/~Mods"
     GameDataMovieMods = "Content/Movies"
-    GameDocumentsDirectory = "%LOCALAPPDATA%/OTWD/Saved/Config/WindowsClient"
+    GameDocumentsDirectory = "%USERPROFILE%/AppData/Local/OTWD/Saved/Config/WindowsClient"
     GameSaveExtension = "sav"
     _main_window: QMainWindow
     _ue4ss_tab: UE4SSTabWidget

games/game_pacificdrive.py

@@ -180,7 +180,7 @@ class PacificDriveGame(BasicGame):
     GameDataUE4SSMods = "Binaries/Win64/Mods"
     GameDataPakMods = "Content/Paks/~Mods"
     GameDataMovieMods = "Content/Movies"
-    GameDocumentsDirectory = "%LOCALAPPDATA%/PenDriverPro/Saved/Config/WindowsNoEditor"
+    GameDocumentsDirectory = "%USERPROFILE%/AppData/Local/PenDriverPro/Saved/Config/WindowsNoEditor"
     GameSaveExtension = "sav"
     _main_window: QMainWindow
     _ue4ss_tab: UE4SSTabWidget

games/game_payday1.py

@@ -199,7 +199,7 @@ class Payday1Game(BasicGame):
     GameSteamId = 24240
     GameBinary = "payday_win32_release.exe"
     GameDataPath = "%GAME_PATH%"
-    GameDocumentsDirectory = "%LOCALAPPDATA%/PAYDAY"
+    GameDocumentsDirectory = "%USERPROFILE%/AppData/Local/PAYDAY"
     _forced_libraries = ["IPHLPAPI.dll", "WSOCK32.dll"]
 
     def init(self, organizer: mobase.IOrganizer) -> bool:

games/game_payday3.py

@@ -212,7 +212,7 @@ class Payday3Game(BasicGame):
     GameDataUE4SSMods = "Binaries/Win64/Mods"
     GameDataPakMods = "Content/Paks/~Mods"
     GameDataMovieMods = "Content/Movies"
-    GameDocumentsDirectory = "%LOCALAPPDATA%/PAYDAY3/Saved/Config/WindowsClient"
+    GameDocumentsDirectory = "%USERPROFILE%/AppData/Local/PAYDAY3/Saved/Config/WindowsClient"
     GameSaveExtension = "sav"
     _main_window: QMainWindow
     _ue4ss_tab: UE4SSTabWidget

games/game_roadtovostok.py

@@ -42,15 +42,15 @@ def fix(self, filetree: mobase.IFileTree) -> mobase.IFileTree:
 class RoadToVostokGame(BasicGame):
 
     Name = "Road to Vostok Support Plugin"
-    Author = "modworkshop"
+    Author = "modworkshop" 
     Version = "1"
     GameName = "Road to Vostok"
     GameShortName = "road-to-vostok"
     GameSteamId = 1963610
     GameBinary = "Road_to_Vostok_Demo.exe"
     GameDataPath = "%GAME_PATH%"
     GameModsPath = "mods"
-    GameDocumentsDirectory = "%APPDATA%/Godot/app_userdata/Road to Vostok"
+    GameDocumentsDirectory = "%USERPROFILE%/AppData/Local/Godot/app_userdata/Road to Vostok"
     GameSaveExtension = "tres"
 
     def init(self, organizer: mobase.IOrganizer) -> bool:

games/game_titanfall2.py

@@ -102,7 +102,9 @@ def _Fix_Installed_Mod(self, mod: mobase.IModInterface):
         ):
             path = mod.absolutePath()
             json_path = os.path.join(path, northstarModPath + "FOLDERNAME/mod.json")
-            mod_data = json.load(open(json_path, encoding="utf-8"))
+            with open(json_path, "r") as json_data:
+                mod_data = json.load(json_data)
+                json_data.close()
             modname = mod_data["name"]
             old_path = os.path.join(path, northstarModPath + "FOLDERNAME")
             new_path = os.path.join(path, northstarModPath + f"{modname}")