eolib 1.2.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

eolib/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.0"
+__version__ = "2.0.1"

eolib/protocol/__init__.py

@@ -1,4 +1,4 @@
-"""	
+"""
 EO protocol data structures.
 
 See Also:

eolib/protocol/_generated/coords.py

@@ -12,8 +12,19 @@ class Coords:
     Map coordinates
     """
     _byte_size: int = 0
-    _x: int = None # type: ignore [assignment]
-    _y: int = None # type: ignore [assignment]
+    _x: int
+    _y: int
+
+    def __init__(self, *, x: int, y: int):
+        """
+        Create a new instance of Coords.
+
+        Args:
+            x (int): (Value range is 0-252.)
+            y (int): (Value range is 0-252.)
+        """
+        self._x = x
+        self._y = y
 
     @property
     def byte_size(self) -> int:
@@ -27,36 +38,12 @@ class Coords:
 
     @property
     def x(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._x
 
-    @x.setter
-    def x(self, x: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._x = x
-
     @property
     def y(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._y
 
-    @y.setter
-    def y(self, y: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._y = y
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Coords") -> None:
         """
@@ -88,14 +75,14 @@ class Coords:
         Returns:
             Coords: The data to serialize.
         """
-        data: Coords = Coords()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._x = reader.get_char()
-            data._y = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            x = reader.get_char()
+            y = reader.get_char()
+            result = Coords(x=x, y=y)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/emf.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .map_warp_row import MapWarpRow
 from .map_type import MapType
 from .map_timed_effect import MapTimedEffect
@@ -23,33 +24,88 @@ class Emf:
     Endless Map File
     """
     _byte_size: int = 0
-    _rid: list[int] = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
-    _type: MapType = None # type: ignore [assignment]
-    _timed_effect: MapTimedEffect = None # type: ignore [assignment]
-    _music_id: int = None # type: ignore [assignment]
-    _music_control: MapMusicControl = None # type: ignore [assignment]
-    _ambient_sound_id: int = None # type: ignore [assignment]
-    _width: int = None # type: ignore [assignment]
-    _height: int = None # type: ignore [assignment]
-    _fill_tile: int = None # type: ignore [assignment]
-    _map_available: bool = None # type: ignore [assignment]
-    _can_scroll: bool = None # type: ignore [assignment]
-    _relog_x: int = None # type: ignore [assignment]
-    _relog_y: int = None # type: ignore [assignment]
-    _npcs_count: int = None # type: ignore [assignment]
-    _npcs: list[MapNpc] = None # type: ignore [assignment]
-    _legacy_door_keys_count: int = None # type: ignore [assignment]
-    _legacy_door_keys: list[MapLegacyDoorKey] = None # type: ignore [assignment]
-    _items_count: int = None # type: ignore [assignment]
-    _items: list[MapItem] = None # type: ignore [assignment]
-    _tile_spec_rows_count: int = None # type: ignore [assignment]
-    _tile_spec_rows: list[MapTileSpecRow] = None # type: ignore [assignment]
-    _warp_rows_count: int = None # type: ignore [assignment]
-    _warp_rows: list[MapWarpRow] = None # type: ignore [assignment]
-    _graphic_layers: list[MapGraphicLayer] = None # type: ignore [assignment]
-    _signs_count: int = None # type: ignore [assignment]
-    _signs: list[MapSign] = None # type: ignore [assignment]
+    _rid: tuple[int, ...]
+    _name: str
+    _type: MapType
+    _timed_effect: MapTimedEffect
+    _music_id: int
+    _music_control: MapMusicControl
+    _ambient_sound_id: int
+    _width: int
+    _height: int
+    _fill_tile: int
+    _map_available: bool
+    _can_scroll: bool
+    _relog_x: int
+    _relog_y: int
+    _npcs_count: int
+    _npcs: tuple[MapNpc, ...]
+    _legacy_door_keys_count: int
+    _legacy_door_keys: tuple[MapLegacyDoorKey, ...]
+    _items_count: int
+    _items: tuple[MapItem, ...]
+    _tile_spec_rows_count: int
+    _tile_spec_rows: tuple[MapTileSpecRow, ...]
+    _warp_rows_count: int
+    _warp_rows: tuple[MapWarpRow, ...]
+    _graphic_layers: tuple[MapGraphicLayer, ...]
+    _signs_count: int
+    _signs: tuple[MapSign, ...]
+
+    def __init__(self, *, rid: Iterable[int], name: str, type: MapType, timed_effect: MapTimedEffect, music_id: int, music_control: MapMusicControl, ambient_sound_id: int, width: int, height: int, fill_tile: int, map_available: bool, can_scroll: bool, relog_x: int, relog_y: int, npcs: Iterable[MapNpc], legacy_door_keys: Iterable[MapLegacyDoorKey], items: Iterable[MapItem], tile_spec_rows: Iterable[MapTileSpecRow], warp_rows: Iterable[MapWarpRow], graphic_layers: Iterable[MapGraphicLayer], signs: Iterable[MapSign]):
+        """
+        Create a new instance of Emf.
+
+        Args:
+            rid (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
+            name (str): (Length must be `24` or less.)
+            type (MapType): 
+            timed_effect (MapTimedEffect): 
+            music_id (int): (Value range is 0-252.)
+            music_control (MapMusicControl): 
+            ambient_sound_id (int): (Value range is 0-64008.)
+            width (int): (Value range is 0-252.)
+            height (int): (Value range is 0-252.)
+            fill_tile (int): (Value range is 0-64008.)
+            map_available (bool): 
+            can_scroll (bool): 
+            relog_x (int): (Value range is 0-252.)
+            relog_y (int): (Value range is 0-252.)
+            npcs (Iterable[MapNpc]): (Length must be 252 or less.)
+            legacy_door_keys (Iterable[MapLegacyDoorKey]): (Length must be 252 or less.)
+            items (Iterable[MapItem]): (Length must be 252 or less.)
+            tile_spec_rows (Iterable[MapTileSpecRow]): (Length must be 252 or less.)
+            warp_rows (Iterable[MapWarpRow]): (Length must be 252 or less.)
+            graphic_layers (Iterable[MapGraphicLayer]): The 9 layers of map graphics. Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2] (Length must be `9`.)
+            signs (Iterable[MapSign]): (Length must be 252 or less.)
+        """
+        self._rid = tuple(rid)
+        self._name = name
+        self._type = type
+        self._timed_effect = timed_effect
+        self._music_id = music_id
+        self._music_control = music_control
+        self._ambient_sound_id = ambient_sound_id
+        self._width = width
+        self._height = height
+        self._fill_tile = fill_tile
+        self._map_available = map_available
+        self._can_scroll = can_scroll
+        self._relog_x = relog_x
+        self._relog_y = relog_y
+        self._npcs = tuple(npcs)
+        self._npcs_count = len(self._npcs)
+        self._legacy_door_keys = tuple(legacy_door_keys)
+        self._legacy_door_keys_count = len(self._legacy_door_keys)
+        self._items = tuple(items)
+        self._items_count = len(self._items)
+        self._tile_spec_rows = tuple(tile_spec_rows)
+        self._tile_spec_rows_count = len(self._tile_spec_rows)
+        self._warp_rows = tuple(warp_rows)
+        self._warp_rows_count = len(self._warp_rows)
+        self._graphic_layers = tuple(graphic_layers)
+        self._signs = tuple(signs)
+        self._signs_count = len(self._signs)
 
     @property
     def byte_size(self) -> int:
@@ -62,315 +118,93 @@ class Emf:
         return self._byte_size
 
     @property
-    def rid(self) -> list[int]:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
+    def rid(self) -> tuple[int, ...]:
         return self._rid
 
-    @rid.setter
-    def rid(self, rid: list[int]) -> None:
-        """
-        Note:
-          - Length must be `2`.
-          - Element value range is 0-64008.
-        """
-        self._rid = rid
-
     @property
     def name(self) -> str:
-        """
-        Note:
-          - Length must be `24` or less.
-        """
         return self._name
 
-    @name.setter
-    def name(self, name: str) -> None:
-        """
-        Note:
-          - Length must be `24` or less.
-        """
-        self._name = name
-
     @property
     def type(self) -> MapType:
         return self._type
 
-    @type.setter
-    def type(self, type: MapType) -> None:
-        self._type = type
-
     @property
     def timed_effect(self) -> MapTimedEffect:
         return self._timed_effect
 
-    @timed_effect.setter
-    def timed_effect(self, timed_effect: MapTimedEffect) -> None:
-        self._timed_effect = timed_effect
-
     @property
     def music_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._music_id
 
-    @music_id.setter
-    def music_id(self, music_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._music_id = music_id
-
     @property
     def music_control(self) -> MapMusicControl:
         return self._music_control
 
-    @music_control.setter
-    def music_control(self, music_control: MapMusicControl) -> None:
-        self._music_control = music_control
-
     @property
     def ambient_sound_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._ambient_sound_id
 
-    @ambient_sound_id.setter
-    def ambient_sound_id(self, ambient_sound_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._ambient_sound_id = ambient_sound_id
-
     @property
     def width(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._width
 
-    @width.setter
-    def width(self, width: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._width = width
-
     @property
     def height(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._height
 
-    @height.setter
-    def height(self, height: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._height = height
-
     @property
     def fill_tile(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._fill_tile
 
-    @fill_tile.setter
-    def fill_tile(self, fill_tile: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._fill_tile = fill_tile
-
     @property
     def map_available(self) -> bool:
         return self._map_available
 
-    @map_available.setter
-    def map_available(self, map_available: bool) -> None:
-        self._map_available = map_available
-
     @property
     def can_scroll(self) -> bool:
         return self._can_scroll
 
-    @can_scroll.setter
-    def can_scroll(self, can_scroll: bool) -> None:
-        self._can_scroll = can_scroll
-
     @property
     def relog_x(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._relog_x
 
-    @relog_x.setter
-    def relog_x(self, relog_x: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._relog_x = relog_x
-
     @property
     def relog_y(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._relog_y
 
-    @relog_y.setter
-    def relog_y(self, relog_y: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._relog_y = relog_y
-
     @property
-    def npcs(self) -> list[MapNpc]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def npcs(self) -> tuple[MapNpc, ...]:
         return self._npcs
 
-    @npcs.setter
-    def npcs(self, npcs: list[MapNpc]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._npcs = npcs
-        self._npcs_count = len(self._npcs)
-
     @property
-    def legacy_door_keys(self) -> list[MapLegacyDoorKey]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def legacy_door_keys(self) -> tuple[MapLegacyDoorKey, ...]:
         return self._legacy_door_keys
 
-    @legacy_door_keys.setter
-    def legacy_door_keys(self, legacy_door_keys: list[MapLegacyDoorKey]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._legacy_door_keys = legacy_door_keys
-        self._legacy_door_keys_count = len(self._legacy_door_keys)
-
     @property
-    def items(self) -> list[MapItem]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def items(self) -> tuple[MapItem, ...]:
         return self._items
 
-    @items.setter
-    def items(self, items: list[MapItem]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._items = items
-        self._items_count = len(self._items)
-
     @property
-    def tile_spec_rows(self) -> list[MapTileSpecRow]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def tile_spec_rows(self) -> tuple[MapTileSpecRow, ...]:
         return self._tile_spec_rows
 
-    @tile_spec_rows.setter
-    def tile_spec_rows(self, tile_spec_rows: list[MapTileSpecRow]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._tile_spec_rows = tile_spec_rows
-        self._tile_spec_rows_count = len(self._tile_spec_rows)
-
     @property
-    def warp_rows(self) -> list[MapWarpRow]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def warp_rows(self) -> tuple[MapWarpRow, ...]:
         return self._warp_rows
 
-    @warp_rows.setter
-    def warp_rows(self, warp_rows: list[MapWarpRow]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._warp_rows = warp_rows
-        self._warp_rows_count = len(self._warp_rows)
-
     @property
-    def graphic_layers(self) -> list[MapGraphicLayer]:
+    def graphic_layers(self) -> tuple[MapGraphicLayer, ...]:
         """
         The 9 layers of map graphics.
         Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2]
-
-        Note:
-          - Length must be `9`.
         """
         return self._graphic_layers
 
-    @graphic_layers.setter
-    def graphic_layers(self, graphic_layers: list[MapGraphicLayer]) -> None:
-        """
-        The 9 layers of map graphics.
-        Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2]
-
-        Note:
-          - Length must be `9`.
-        """
-        self._graphic_layers = graphic_layers
-
     @property
-    def signs(self) -> list[MapSign]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def signs(self) -> tuple[MapSign, ...]:
         return self._signs
 
-    @signs.setter
-    def signs(self, signs: list[MapSign]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._signs = signs
-        self._signs_count = len(self._signs)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "Emf") -> None:
         """
@@ -505,57 +339,57 @@ class Emf:
         Returns:
             Emf: The data to serialize.
         """
-        data: Emf = Emf()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_fixed_string(3, False)
-            data._rid = []
+            rid = []
             for i in range(2):
-                data._rid.append(reader.get_short())
-            data._name = reader.get_fixed_encoded_string(24, True)
-            data._type = MapType(reader.get_char())
-            data._timed_effect = MapTimedEffect(reader.get_char())
-            data._music_id = reader.get_char()
-            data._music_control = MapMusicControl(reader.get_char())
-            data._ambient_sound_id = reader.get_short()
-            data._width = reader.get_char()
-            data._height = reader.get_char()
-            data._fill_tile = reader.get_short()
-            data._map_available = reader.get_char() != 0
-            data._can_scroll = reader.get_char() != 0
-            data._relog_x = reader.get_char()
-            data._relog_y = reader.get_char()
+                rid.append(reader.get_short())
+            name = reader.get_fixed_encoded_string(24, True)
+            type = MapType(reader.get_char())
+            timed_effect = MapTimedEffect(reader.get_char())
+            music_id = reader.get_char()
+            music_control = MapMusicControl(reader.get_char())
+            ambient_sound_id = reader.get_short()
+            width = reader.get_char()
+            height = reader.get_char()
+            fill_tile = reader.get_short()
+            map_available = reader.get_char() != 0
+            can_scroll = reader.get_char() != 0
+            relog_x = reader.get_char()
+            relog_y = reader.get_char()
             reader.get_char()
-            data._npcs_count = reader.get_char()
-            data._npcs = []
-            for i in range(data._npcs_count):
-                data._npcs.append(MapNpc.deserialize(reader))
-            data._legacy_door_keys_count = reader.get_char()
-            data._legacy_door_keys = []
-            for i in range(data._legacy_door_keys_count):
-                data._legacy_door_keys.append(MapLegacyDoorKey.deserialize(reader))
-            data._items_count = reader.get_char()
-            data._items = []
-            for i in range(data._items_count):
-                data._items.append(MapItem.deserialize(reader))
-            data._tile_spec_rows_count = reader.get_char()
-            data._tile_spec_rows = []
-            for i in range(data._tile_spec_rows_count):
-                data._tile_spec_rows.append(MapTileSpecRow.deserialize(reader))
-            data._warp_rows_count = reader.get_char()
-            data._warp_rows = []
-            for i in range(data._warp_rows_count):
-                data._warp_rows.append(MapWarpRow.deserialize(reader))
-            data._graphic_layers = []
+            npcs_count = reader.get_char()
+            npcs = []
+            for i in range(npcs_count):
+                npcs.append(MapNpc.deserialize(reader))
+            legacy_door_keys_count = reader.get_char()
+            legacy_door_keys = []
+            for i in range(legacy_door_keys_count):
+                legacy_door_keys.append(MapLegacyDoorKey.deserialize(reader))
+            items_count = reader.get_char()
+            items = []
+            for i in range(items_count):
+                items.append(MapItem.deserialize(reader))
+            tile_spec_rows_count = reader.get_char()
+            tile_spec_rows = []
+            for i in range(tile_spec_rows_count):
+                tile_spec_rows.append(MapTileSpecRow.deserialize(reader))
+            warp_rows_count = reader.get_char()
+            warp_rows = []
+            for i in range(warp_rows_count):
+                warp_rows.append(MapWarpRow.deserialize(reader))
+            graphic_layers = []
             for i in range(9):
-                data._graphic_layers.append(MapGraphicLayer.deserialize(reader))
-            data._signs_count = reader.get_char()
-            data._signs = []
-            for i in range(data._signs_count):
-                data._signs.append(MapSign.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                graphic_layers.append(MapGraphicLayer.deserialize(reader))
+            signs_count = reader.get_char()
+            signs = []
+            for i in range(signs_count):
+                signs.append(MapSign.deserialize(reader))
+            result = Emf(rid=rid, name=name, type=type, timed_effect=timed_effect, music_id=music_id, music_control=music_control, ambient_sound_id=ambient_sound_id, width=width, height=height, fill_tile=fill_tile, map_available=map_available, can_scroll=can_scroll, relog_x=relog_x, relog_y=relog_y, npcs=npcs, legacy_door_keys=legacy_door_keys, items=items, tile_spec_rows=tile_spec_rows, warp_rows=warp_rows, graphic_layers=graphic_layers, signs=signs)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode