feat: implement configfile

Basically still ConfigParser

vollerei/common/__init__.py

@@ -0,0 +1,4 @@
+from vollerei.common.configfile import ConfigFile
+from vollerei.common.telemetry import block_telemetry, check_telemetry
+
+__all__ = ["ConfigFile", "block_telemetry", "check_telemetry"]

vollerei/common/configfile.py

@@ -0,0 +1,15 @@
+from configparser import ConfigParser
+from pathlib import Path
+
+
+class ConfigFile(ConfigParser):
+    path: Path
+
+    def __init__(self, path, **kwargs):
+        super().__init__(**kwargs)
+        self.path = Path(path)
+        self.read(self.path)
+
+    def save(self):
+        with self.path.open("w") as f:
+            self.write(f)

vollerei/hsr/launcher/game.py

@@ -2,6 +2,7 @@ from hashlib import md5
 from os import PathLike
 from pathlib import Path
 from enum import Enum
+from vollerei.common import ConfigFile
 from vollerei.abc.launcher.game import GameABC
 from vollerei.hsr.constants import MD5SUMS
 
@@ -89,6 +90,24 @@ class Game(GameABC):
             return False
         return True
 
+    def _get_version_config(self) -> tuple[int, int, int]:
+        cfg_file = self._path.joinpath("config.ini")
+        if not cfg_file.exists():
+            return (0, 0, 0)
+        cfg = ConfigFile(cfg_file)
+        if "General" not in cfg.sections():
+            return (0, 0, 0)
+        if "game_version" not in cfg["General"]:
+            return (0, 0, 0)
+        version_str = cfg["General"]["game_version"]
+        if version_str.count(".") != 2:
+            return (0, 0, 0)
+        try:
+            version = tuple(int(i) for i in version_str.split("."))
+        except Exception:
+            return (0, 0, 0)
+        return version
+
     def get_version(self) -> tuple[int, int, int]:
         """
         Get the current installed game version.
@@ -116,36 +135,40 @@ class Game(GameABC):
         version_bytes: list[list[bytes]] = [[], [], []]
         version_ptr = 0
         correct = True
-        with self.data_folder().joinpath("data.unity3d").open("rb") as f:
+        try:
-            f.seek(0x7D0)  # 2000 in decimal
+            with self.data_folder().joinpath("data.unity3d").open("rb") as f:
-            for byte in f.read(10000):
+                f.seek(0x7D0)  # 2000 in decimal
-                match byte:
+                for byte in f.read(10000):
-                    case 0:
+                    match byte:
-                        version_bytes = [[], [], []]
+                        case 0:
-                        version_ptr = 0
+                            version_bytes = [[], [], []]
-                        correct = True
+                            version_ptr = 0
-                    case 46:
+                            correct = True
-                        version_ptr += 1
+                        case 46:
-                        if version_ptr > 2:
+                            version_ptr += 1
-                            correct = False
+                            if version_ptr > 2:
-                    case 38:
+                                correct = False
-                        if (
+                        case 38:
-                            correct
+                            if (
-                            and len(version_bytes[0]) > 0
+                                correct
-                            and len(version_bytes[1]) > 0
+                                and len(version_bytes[0]) > 0
-                            and len(version_bytes[2]) > 0
+                                and len(version_bytes[1]) > 0
-                        ):
+                                and len(version_bytes[2]) > 0
-                            return (
+                            ):
-                                bytes_to_int(version_bytes[0]),
+                                return (
-                                bytes_to_int(version_bytes[1]),
+                                    bytes_to_int(version_bytes[0]),
-                                bytes_to_int(version_bytes[2]),
+                                    bytes_to_int(version_bytes[1]),
-                            )
+                                    bytes_to_int(version_bytes[2]),
-                    case _:
+                                )
-                        if correct and byte in allowed:
+                        case _:
-                            version_bytes[version_ptr].append(byte)
+                            if correct and byte in allowed:
-                        else:
+                                version_bytes[version_ptr].append(byte)
-                            correct = False
+                            else:
-        return (0, 0, 0)
+                                correct = False
+        except Exception:
+            pass
+        # Fallback to config.ini
+        return self._get_version_config()
 
     def get_version_str(self) -> str:
         """