koro 1.1.6__py3-none-any.whl → 2.0.0rc2__py3-none-any.whl

koro/__init__.py

@@ -1,8 +1,8 @@
-from .file import *
-from .file.bin import *
-from .file.dir import *
-from .file.lvl import *
-from .file.zip import *
-from .item.group import *
-from .item.level import *
-from .item.save import *
+from .slot import *
+from .slot.bin import *
+from .slot.file import *
+from .slot.save import *
+from .slot.xml import *
+from .stage import *
+from .stage.model import *
+from .stage.part import *

koro/slot/__init__.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from ..stage import Stage
+
+__all__ = ["Slot"]
+
+
+class Slot(ABC):
+    __slots__ = ()
+
+    def __bool__(self) -> bool:
+        """Return whether this slot is filled."""
+        return self.load() is not None
+
+    @abstractmethod
+    def load(self) -> Stage | None:
+        pass
+
+    @abstractmethod
+    def save(self, data: Stage | None, /) -> None:
+        pass

koro/{file → slot}/bin.py

@@ -1,22 +1,16 @@
 from itertools import chain
 from typing import Final
 
-from ..item.level import Level, LevelNotFoundError
-from . import Location
+from ..stage import Stage
+from .file import FileSlot
+from .xml import XmlSlot
 
-__all__ = ["BinLevel", "BinLevelNotFoundError"]
 
-
-class BinLevelNotFoundError(FileNotFoundError, LevelNotFoundError):
-    pass
-
-
-class BinLevel(Location, Level):
+class BinSlot(FileSlot):
     __slots__ = ()
 
     @staticmethod
     def compress(data: bytes, /) -> bytes:
-        """Compress the given level data into the game's format."""
         buffer: bytearray = bytearray(1024)
         buffer_index: int = 958
         chunk: bytearray
@@ -117,11 +111,10 @@ class BinLevel(Location, Level):
                 )
                 data_index += test_length
             output.extend(chunk)
-        return bytes(output + b"\x00" * (len(output) & 1))
+        return bytes(output)
 
     @staticmethod
     def decompress(data: bytes, /) -> bytes:
-        """Decompress the given data into raw level data."""
         buffer: Final[bytearray] = bytearray(1024)
         buffer_index: int = 958
         handle: int | bytearray
@@ -151,29 +144,12 @@ class BinLevel(Location, Level):
                         buffer_index = buffer_index + 1 & 1023
                     result.extend(handle)
                 flags >>= 1
-        return bytes(result.replace(b"<EDITUSER> 3 </EDITUSER>", b"<EDITUSER> 2 </EDITUSER>"))
-
-    def delete(self) -> None:
-        try:
-            return super().delete()
-        except FileNotFoundError as e:
-            raise BinLevelNotFoundError(*e.args)
+        return bytes(result)
 
-    def __len__(self) -> int:
-        try:
-            with open(self.path, "rb") as f:
-                f.seek(8)
-                return int.from_bytes(f.read(4), byteorder="big")
-        except FileNotFoundError as e:
-            BinLevelNotFoundError(*e.args)
-
-    def read(self) -> bytes:
-        try:
-            with open(self.path, "rb") as f:
-                return self.decompress(f.read())
-        except FileNotFoundError as e:
-            raise BinLevelNotFoundError(*e.args)
+    @staticmethod
+    def deserialize(data: bytes, /) -> Stage:
+        return XmlSlot.deserialize(BinSlot.decompress(data))
 
-    def write(self, new_content: bytes, /) -> None:
-        with open(self.path, "wb") as f:
-            f.write(self.compress(new_content))
+    @staticmethod
+    def serialize(level: Stage, /) -> bytes:
+        return BinSlot.compress(XmlSlot.serialize(level))

koro/slot/file.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from os import remove
+from os.path import isfile
+from typing import TYPE_CHECKING, Any
+
+from ..stage import Stage
+from . import Slot
+
+if TYPE_CHECKING:
+    from _typeshed import StrOrBytesPath
+else:
+    StrOrBytesPath = Any
+
+
+class FileSlot(Slot, ABC):
+    __match_args__ = ("path",)
+    __slots__ = ("_path",)
+
+    _path: StrOrBytesPath
+
+    def __init__(self, path: StrOrBytesPath, /) -> None:
+        self._path = path
+
+    def __bool__(self) -> bool:
+        return isfile(self.path)
+
+    @staticmethod
+    @abstractmethod
+    def deserialize(data: bytes, /) -> Stage:
+        pass
+
+    def __eq__(self, other: object, /) -> bool:
+        if isinstance(other, FileSlot) and (
+            isinstance(other, type(self)) or isinstance(self, type(other))
+        ):
+            return self.path == other.path
+        else:
+            return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.path)
+
+    def load(self) -> Stage | None:
+        try:
+            with open(self.path, "rb") as f:
+                return self.deserialize(f.read())
+        except FileNotFoundError:
+            return None
+
+    @property
+    def path(self) -> StrOrBytesPath:
+        return self._path
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.path!r})"
+
+    def save(self, data: Stage | None) -> None:
+        if data is None:
+            remove(self.path)
+        else:
+            with open(self.path, "wb") as f:
+                f.write(self.serialize(data))
+
+    @staticmethod
+    @abstractmethod
+    def serialize(stage: Stage, /) -> bytes:
+        pass

koro/slot/save.py

@@ -0,0 +1,135 @@
+from enum import Enum, unique
+from io import BytesIO
+from operator import index as ix
+from os.path import basename, dirname, join
+from typing import TYPE_CHECKING, Annotated, Any, Literal, SupportsIndex
+from collections.abc import Mapping, Sequence
+
+from ..stage import Stage
+
+from . import Slot
+from .xml import XmlSlot
+
+if TYPE_CHECKING:
+    from _typeshed import StrOrBytesPath
+
+
+__all__ = ["EditorPage", "get_slots", "SaveSlot"]
+
+
+@unique
+class EditorPage(Enum):
+    ORIGINAL = 0
+    FRIEND = 1
+    HUDSON = 2
+
+
+class SaveSlot(Slot):
+    __match_args__ = ("path", "page", "index")
+    __slots__ = ("_offset", "_path")
+
+    _offset: Literal[8, 156392, 312776, 469160]
+    _path: str | bytes
+
+    def __init__(
+        self,
+        path: StrOrBytesPath,
+        page: EditorPage,
+        index: Annotated[
+            SupportsIndex,
+            Literal[
+                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20
+            ],
+        ],
+    ) -> None:
+        index = ix(index) - 1
+        if index in range(0, 20):
+            self._offset = 8 + 156864 * (index & 3)  # type: ignore[assignment]
+            self._path = join(path, f"ed{(index >> 2) + 5 * page.value:02}.dat")  # type: ignore[arg-type]
+        else:
+            raise ValueError("index must be between 1 and 20")
+
+    def __bool__(self) -> bool:
+        try:
+            with open(self._path, "rb") as f:
+                f.seek(self._offset)
+                return f.read(1) != b"\x00"
+        except FileNotFoundError:
+            return False
+
+    def __eq__(self, other: Any, /) -> bool:
+        if isinstance(other, SaveSlot):
+            return self._path == other._path and self._offset == other._offset
+        else:
+            return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash((self._offset, self._path))
+
+    @property
+    def index(
+        self,
+    ) -> Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]:
+        return (int(basename(self._path)[2:4]) % 5 >> 2 | self._offset // 156864) + 1  # type: ignore[return-value]
+
+    def load(self) -> Stage | None:
+        try:
+            with open(self._path, "rb") as f:
+                f.seek(self._offset)
+                with BytesIO() as b:
+                    block: bytearray = bytearray()
+                    while True:
+                        block.clear()
+                        f.readinto1(block)
+                        if len(b.getbuffer()) + len(block) > 156864:
+                            del block[156864 - len(b.getbuffer()) :]
+                        if block[-1]:
+                            b.write(block)
+                        else:
+                            while block:
+                                if block[len(block) >> 1]:
+                                    b.write(block[: (len(block) >> 1) + 1])
+                                    del block[: (len(block) >> 1) + 1]
+                                else:
+                                    del block[len(block) >> 1 :]
+                            data: bytes = b.getvalue()
+                            if data:
+                                return XmlSlot.deserialize(data)
+                            else:
+                                return None
+        except FileNotFoundError:
+            return None
+
+    @property
+    def page(self) -> EditorPage:
+        return EditorPage(int(basename(self._path)[2:4]) // 5)
+
+    @property
+    def path(self) -> StrOrBytesPath:
+        return dirname(self._path)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.path!r}, {self.page!r}, {self.index!r})"
+
+    def save(self, data: Stage | None) -> None:
+        binary: bytes = b"" if data is None else XmlSlot.serialize(data)
+        if len(binary) > 156864:
+            raise ValueError("serialized level data is too large to save")
+        try:
+            with open(self._path, "xb") as f:
+                f.write(bytes(638976))
+            if data is None:
+                return
+        except FileExistsError:
+            pass
+        with open(self._path, "r+b") as f:
+            f.seek(self._offset)
+            f.write(binary)
+            f.write(bytes(156864 - len(binary)))
+
+
+def get_slots(save: StrOrBytesPath, /) -> Mapping[EditorPage, Sequence[SaveSlot]]:
+    return {
+        page: tuple(SaveSlot(save, page, i) for i in range(1, 21))
+        for page in EditorPage
+    }