vollerei/cli/__init__.py

@@ -1,6 +0,0 @@
-from typing import Any
-
-
-class CLI:
-    def __init__(self):
-        pass

vollerei/constants.py

@@ -1,3 +1,5 @@
+from platformdirs import PlatformDirs
+
 # Common
 telemetry_hosts = [
     # Global
@@ -12,3 +14,13 @@ telemetry_hosts = [
 # HSR
 astra_repo = "https://notabug.org/mkrsym1/astra"
 jadeite_repo = "https://codeberg.org/mkrsym1/jadeite/"
+hsr_latest_version = (1, 1, 0)
+
+base_dirs = PlatformDirs("vollerei", "tretrauit", roaming=True)
+tools_data_path = base_dirs.site_data_path.joinpath("tools")
+tools_cache_path = base_dirs.site_cache_path.joinpath("tools")
+tools_cache_path.mkdir(parents=True, exist_ok=True)
+launcher_cache_path = base_dirs.site_cache_path.joinpath("launcher")
+launcher_cache_path.mkdir(parents=True, exist_ok=True)
+utils_cache_path = base_dirs.site_cache_path.joinpath("utils")
+utils_cache_path.mkdir(parents=True, exist_ok=True)

vollerei/hsr/constants.py

@@ -1,13 +0,0 @@
-latest_version = (1, 1, 0)
-md5sums = {
-    "1.0.5": {
-        "cn": {
-            "StarRailBase.dll": "66c42871ce82456967d004ccb2d7cf77",
-            "UnityPlayer.dll": "0c866c44bb3752031a8c12ffe935b26f",
-        },
-        "os": {
-            "StarRailBase.dll": "8aa3790aafa3dd176678392f3f93f435",
-            "UnityPlayer.dll": "f17b9b7f9b8c9cbd211bdff7771a80c2",
-        },
-    }
-}

vollerei/hsr/launcher/game.py

@@ -1,44 +1,17 @@
-from hashlib import md5
 from os import PathLike
 from pathlib import Path
-from enum import Enum
 from vollerei.abc.launcher.game import GameABC
-from vollerei.hsr.constants import md5sums
-
-
-class GameChannel(Enum):
-    Overseas = 0
-    China = 1
 
 
 class Game(GameABC):
     def __init__(self, path: PathLike = None):
-        self._path: Path | None = Path(path) if path else None
+        self.path: Path | None = Path(path) if path else None
-
-    @property
-    def path(self) -> Path | None:
-        return self._path
 
     def is_installed(self) -> bool:
-        if self._path is None:
+        if self.path is None:
             return False
         if (
-            not self._path.joinpath("StarRail.exe").exists()
+            not self.path.joinpath("StarRail.exe").exists()
-            or not self._path.joinpath("StarRailBase.dll").exists()
+            or not self.path.joinpath("StarRailBase.dll").exists()
         ):
             return False
-
-    def get_channel(self) -> GameChannel:
-        if self.get_version() == (1, 0, 5):
-            for channel, v in md5sums["1.0.5"].values():
-                for file, md5sum in v.values():
-                    if (
-                        md5(self._path.joinpath(file).read_bytes()).hexdigest()
-                        != md5sum
-                    ):
-                        continue
-                    match channel:
-                        case "cn":
-                            return GameChannel.China
-                        case "os":
-                            return GameChannel.Overseas

vollerei/hsr/patcher.py

@@ -1,14 +1,10 @@
-from pathlib import Path
-from enum import Enum
-from shutil import copy2
-from distutils.version import StrictVersion
 from vollerei.abc.patcher import PatcherABC
 from vollerei.exceptions.game import GameNotInstalledError
 from vollerei.exceptions.patcher import VersionNotSupportedError
-from vollerei.hsr.launcher.game import Game, GameChannel
+from vollerei.hsr.launcher.game import Game
-from vollerei.utils import download_and_extract, Git, Xdelta3
+from vollerei.utils.git import Git
-from vollerei.paths import tools_data_path
+from vollerei.constants import tools_data_path, astra_repo, jadeite_repo
-from vollerei.constants import astra_repo, jadeite_repo
+from enum import Enum
 
 
 class PatchType(Enum):
@@ -27,11 +23,7 @@ class Patcher(PatcherABC):
     def __init__(self, patch_type: PatchType = PatchType.Jadeite):
         self._patch_type: PatchType = patch_type
         self._path = tools_data_path.joinpath("patcher")
-        self._path.mkdir(parents=True, exist_ok=True)
-        self._jadeite = self._path.joinpath("jadeite")
-        self._astra = self._path.joinpath("astra")
         self._git = Git()
-        self._xdelta3 = Xdelta3()
 
     @property
     def patch_type(self) -> PatchType:
@@ -42,21 +34,10 @@ class Patcher(PatcherABC):
         self._patch_type = value
 
     def _update_astra(self):
-        self._git.pull_or_clone(astra_repo, self._astra)
+        self._git.pull_or_clone(astra_repo, self._path.joinpath("astra"))
 
     def _update_jadeite(self):
-        file = self._git.get_latest_release_dl(jadeite_repo)[0]
+        self._git.pull_or_clone(jadeite_repo, self._path.joinpath("jadeite"))
-        file_version = Path(file).stem[1:]
-        current_version = None
-        if self._jadeite.joinpath("version").exists():
-            with open(self._jadeite.joinpath("version"), "r") as f:
-                current_version = f.read()
-        if current_version:
-            if StrictVersion(file_version) <= StrictVersion(current_version):
-                return
-        download_and_extract(file, self._jadeite)
-        with open(self._jadeite.joinpath("version"), "w") as f:
-            f.write(file_version)
 
     def update_patch(self):
         match self._patch_type:
@@ -70,54 +51,10 @@ class Patcher(PatcherABC):
             raise VersionNotSupportedError(
                 "Only version 1.0.5 is supported by Astra patch."
             )
-        self._update_astra()
-        file_type = None
-        match game.get_channel():
-            case GameChannel.China:
-                file_type = "cn"
-            case GameChannel.Overseas:
-                file_type = "os"
-        # Backup
-        for file in ["UnityPlayer.dll", "StarRailBase.dll"]:
-            game.path.joinpath(file).rename(game.path.joinpath(f"{file}.bak"))
-        # Patch
-        for file in ["UnityPlayer.dll", "StarRailBase.dll"]:
-            self._xdelta3.patch_file(
-                self._astra.joinpath(f"{file_type}/diffs/{file}.vcdiff"),
-                game.path.joinpath(f"{file}.bak"),
-                game.path.joinpath(file),
-            )
-        # Copy files
-        for file in self._astra.joinpath(f"{file_type}/files/").rglob("*"):
-            if file.suffix == ".bat":
-                continue
-            if file.is_dir():
-                game.path.joinpath(
-                    file.relative_to(self._astra.joinpath(f"{file_type}/files/"))
-                ).mkdir(parents=True, exist_ok=True)
-            copy2(
-                file,
-                game.path.joinpath(
-                    file.relative_to(self._astra.joinpath(f"{file_type}/files/"))
-                ),
-            )
 
-    def _patch_jadeite(self):
+    def _patch_jadeite(self, game: Game):
-        """
+        pass
-        "Patch" the game with Jadeite patch.
-
-        Unlike Astra patch, Jadeite patch does not modify the game files directly
-        but uses DLLs to patch the game in memory and it has an injector to do that
-        automatically.
-        """
-        self._update_jadeite()
-        return self._jadeite
 
     def patch_game(self, game: Game):
         if not game.is_installed():
             raise GameNotInstalledError("Game is not installed")
-        match self._patch_type:
-            case PatchType.Astra:
-                self._patch_astra(game)
-            case PatchType.Jadeite:
-                return self._patch_jadeite()

vollerei/paths.py

@@ -1,21 +0,0 @@
-from pathlib import Path
-from platformdirs import PlatformDirs
-
-
-base_paths = PlatformDirs("vollerei", "tretrauit", roaming=True)
-tools_data_path: Path = None
-tools_cache_path: Path = None
-launcher_cache_path: Path = None
-utils_cache_path: Path = None
-
-
-def init_paths():
-    global tools_data_path, tools_cache_path, launcher_cache_path, utils_cache_path
-    tools_data_path = base_paths.site_data_path.joinpath("tools")
-    tools_cache_path = base_paths.site_cache_path.joinpath("tools")
-    launcher_cache_path = base_paths.site_cache_path.joinpath("launcher")
-    utils_cache_path = base_paths.site_cache_path.joinpath("utils")
-    tools_data_path.mkdir(parents=True, exist_ok=True)
-    tools_cache_path.mkdir(parents=True, exist_ok=True)
-    launcher_cache_path.mkdir(parents=True, exist_ok=True)
-    utils_cache_path.mkdir(parents=True, exist_ok=True)

vollerei/utils/__init__.py

@@ -1,22 +0,0 @@
-import requests
-from zipfile import ZipFile
-from io import BytesIO
-from pathlib import Path
-
-# Re-exports
-from vollerei.utils.git import Git
-from vollerei.utils.xdelta3 import Xdelta3
-
-
-__all__ = ["Git", "Xdelta3", "download_and_extract"]
-
-
-def download_and_extract(url: str, path: Path) -> None:
-    rsp = requests.get(url, stream=True)
-    rsp.raise_for_status()
-    with BytesIO() as f:
-        for chunk in rsp.iter_content(chunk_size=32768):
-            f.write(chunk)
-        f.seek(0)
-        with ZipFile(f) as z:
-            z.extractall(path)

vollerei/utils/git/__init__.py

@@ -2,11 +2,12 @@ import subprocess
 import requests
 import json
 from pathlib import Path
+from zipfile import ZipFile
+from io import BytesIO
 from shutil import which, rmtree
 from urllib.parse import urlparse
 from vollerei.constants import utils_cache_path
 from vollerei.utils.git.exceptions import GitCloneError
-from vollerei.utils import download_and_extract
 
 
 class Git:
@@ -21,7 +22,7 @@ class Git:
         self._cache.mkdir(parents=True, exist_ok=True)
 
     @staticmethod
-    def is_installed() -> bool:
+    def is_installed():
         """
         Check for git installation
 
@@ -61,7 +62,14 @@ class Git:
         return data[0]["sha"]
 
     def _download_and_extract_zip(self, url: str, path: Path) -> None:
-        download_and_extract(url, path)
+        rsp = requests.get(url, stream=True)
+        rsp.raise_for_status()
+        file = BytesIO()
+        with open(file, "wb") as f:
+            for chunk in rsp.iter_content(chunk_size=32768):
+                f.write(chunk)
+        zip_file = ZipFile(file)
+        zip_file.extractall(path)
         path.joinpath(".git/PLEASE_INSTALL_GIT").touch()
 
     def _clone(self, url: str, path: str = None) -> None:
@@ -91,23 +99,6 @@ class Git:
         else:
             raise NotImplementedError
 
-    def get_latest_release_dl(self, url: str) -> list[str]:
-        dl = []
-        if Path(url).suffix == ".git":
-            url = url[:-4]
-        url_info = urlparse(url)
-        netloc = url_info.netloc
-        if self._is_gitea(netloc):
-            rsp = requests.get(
-                f"https://{netloc}/api/v1/repos/{url_info.path}/releases/latest",
-            )
-            rsp.raise_for_status()
-            data = rsp.json()
-            for asset in data["assets"]:
-                dl.append(asset["browser_download_url"])
-        else:
-            raise NotImplementedError
-
     def pull_or_clone(self, url: str, path: str = None) -> None:
         """
         Pulls or clones a git repository