Added Save Error Handling, Additional Save Meta and Local Save Fix

Authored by Cuteness with small edits by Floofytsuna

Author: TsunaMoo

games/game_cassettebeasts.py

@@ -1,16 +1,17 @@
-from collections.abc import Mapping
-from io import BytesIO
 import json
-import mobase
 import math
 import os
 import shutil
 import struct
-import sys
 import zlib
+import mobase
 
-from pathlib import Path
+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
 
 from ..basic_features import BasicLocalSavegames
 from ..basic_features.basic_save_game_info import (BasicGameSaveGame,BasicGameSaveGameInfo)
@@ -19,6 +20,13 @@
 from PyQt6.QtCore import QDateTime, QDir, QFile, 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):
         super().__init__()
@@ -64,72 +72,113 @@ def __init__(self):
 class CassetteBeastsSaveGame(BasicGameSaveGame):
     def __init__(self, filepath: Path):
         super().__init__(filepath)
-        self.name: str = ""
-        self.cheated: str = ""
-        self.lastsave: int = 0
-        self.elapsed: int = 0
-        info = bytearray()
-        data = bytes()
+        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:
+                magic_string = infile.read(4)
 
-        with open(filepath, 'rb') as infile:
-            magic_string = infile.read(4)
+                compression_mode, blocksize, raw_size = struct.unpack("III", infile.read(12))
 
-            compression_mode, blocksize, raw_size = struct.unpack("III", infile.read(12))
+                num_blocks = math.ceil(raw_size / blocksize)
 
-            num_blocks = math.ceil(raw_size / blocksize)
+                blocks = []
 
-            blocks = []
+                for bnum in range(num_blocks):
+                    block = CassetteBlock()
+                    block.compressed_size = struct.unpack("I", infile.read(4))[0]
+                    blocks.append(block)
 
-            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)
 
+                magic_string = infile.read(4)
+                infile.close()
             for block in blocks:
-              block.data = infile.read(block.compressed_size)
-
-            magic_string = 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))
-        self.name = save_data["party"]["player"]["custom"]["name"]
-        self.cheated = save_data["has_cheated"]
+                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 {
-        "Character": save.getName(),
-        "Cheated": save.getCheated()
+        "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"
+    GameDataPath = os.getenv("APPDATA") + "/CassetteBeasts/mods"
+    GameDocumentsDirectory = os.getenv("APPDATA") + "/CassetteBeasts"
     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(BasicLocalSavegames(QDir(self.GameDocumentsDirectory)))
         self._register_feature(
             BasicGameSaveGameInfo(None, getMetadata)
         )