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

eolib/protocol/_generated/map/map_graphic_layer.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .map_graphic_row import MapGraphicRow
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,8 +15,18 @@ class MapGraphicLayer:
     A layer of map graphics
     """
     _byte_size: int = 0
-    _graphic_rows_count: int = None # type: ignore [assignment]
-    _graphic_rows: list[MapGraphicRow] = None # type: ignore [assignment]
+    _graphic_rows_count: int
+    _graphic_rows: tuple[MapGraphicRow, ...]
+
+    def __init__(self, *, graphic_rows: Iterable[MapGraphicRow]):
+        """
+        Create a new instance of MapGraphicLayer.
+
+        Args:
+            graphic_rows (Iterable[MapGraphicRow]): (Length must be 252 or less.)
+        """
+        self._graphic_rows = tuple(graphic_rows)
+        self._graphic_rows_count = len(self._graphic_rows)
 
     @property
     def byte_size(self) -> int:
@@ -28,22 +39,9 @@ class MapGraphicLayer:
         return self._byte_size
 
     @property
-    def graphic_rows(self) -> list[MapGraphicRow]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def graphic_rows(self) -> tuple[MapGraphicRow, ...]:
         return self._graphic_rows
 
-    @graphic_rows.setter
-    def graphic_rows(self, graphic_rows: list[MapGraphicRow]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._graphic_rows = graphic_rows
-        self._graphic_rows_count = len(self._graphic_rows)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapGraphicLayer") -> None:
         """
@@ -78,16 +76,16 @@ class MapGraphicLayer:
         Returns:
             MapGraphicLayer: The data to serialize.
         """
-        data: MapGraphicLayer = MapGraphicLayer()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._graphic_rows_count = reader.get_char()
-            data._graphic_rows = []
-            for i in range(data._graphic_rows_count):
-                data._graphic_rows.append(MapGraphicRow.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+            graphic_rows_count = reader.get_char()
+            graphic_rows = []
+            for i in range(graphic_rows_count):
+                graphic_rows.append(MapGraphicRow.deserialize(reader))
+            result = MapGraphicLayer(graphic_rows=graphic_rows)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_graphic_row.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .map_graphic_row_tile import MapGraphicRowTile
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,9 +15,21 @@ class MapGraphicRow:
     A row in a layer of map graphics
     """
     _byte_size: int = 0
-    _y: int = None # type: ignore [assignment]
-    _tiles_count: int = None # type: ignore [assignment]
-    _tiles: list[MapGraphicRowTile] = None # type: ignore [assignment]
+    _y: int
+    _tiles_count: int
+    _tiles: tuple[MapGraphicRowTile, ...]
+
+    def __init__(self, *, y: int, tiles: Iterable[MapGraphicRowTile]):
+        """
+        Create a new instance of MapGraphicRow.
+
+        Args:
+            y (int): (Value range is 0-252.)
+            tiles (Iterable[MapGraphicRowTile]): (Length must be 252 or less.)
+        """
+        self._y = y
+        self._tiles = tuple(tiles)
+        self._tiles_count = len(self._tiles)
 
     @property
     def byte_size(self) -> int:
@@ -30,37 +43,12 @@ class MapGraphicRow:
 
     @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
-
     @property
-    def tiles(self) -> list[MapGraphicRowTile]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def tiles(self) -> tuple[MapGraphicRowTile, ...]:
         return self._tiles
 
-    @tiles.setter
-    def tiles(self, tiles: list[MapGraphicRowTile]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._tiles = tiles
-        self._tiles_count = len(self._tiles)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapGraphicRow") -> None:
         """
@@ -98,17 +86,17 @@ class MapGraphicRow:
         Returns:
             MapGraphicRow: The data to serialize.
         """
-        data: MapGraphicRow = MapGraphicRow()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._y = reader.get_char()
-            data._tiles_count = reader.get_char()
-            data._tiles = []
-            for i in range(data._tiles_count):
-                data._tiles.append(MapGraphicRowTile.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+            y = reader.get_char()
+            tiles_count = reader.get_char()
+            tiles = []
+            for i in range(tiles_count):
+                tiles.append(MapGraphicRowTile.deserialize(reader))
+            result = MapGraphicRow(y=y, tiles=tiles)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_graphic_row_tile.py

@@ -12,8 +12,19 @@ class MapGraphicRowTile:
     A single tile in a row of map graphics
     """
     _byte_size: int = 0
-    _x: int = None # type: ignore [assignment]
-    _graphic: int = None # type: ignore [assignment]
+    _x: int
+    _graphic: int
+
+    def __init__(self, *, x: int, graphic: int):
+        """
+        Create a new instance of MapGraphicRowTile.
+
+        Args:
+            x (int): (Value range is 0-252.)
+            graphic (int): (Value range is 0-64008.)
+        """
+        self._x = x
+        self._graphic = graphic
 
     @property
     def byte_size(self) -> int:
@@ -27,36 +38,12 @@ class MapGraphicRowTile:
 
     @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 graphic(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._graphic
 
-    @graphic.setter
-    def graphic(self, graphic: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._graphic = graphic
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapGraphicRowTile") -> None:
         """
@@ -88,14 +75,14 @@ class MapGraphicRowTile:
         Returns:
             MapGraphicRowTile: The data to serialize.
         """
-        data: MapGraphicRowTile = MapGraphicRowTile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._x = reader.get_char()
-            data._graphic = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            x = reader.get_char()
+            graphic = reader.get_short()
+            result = MapGraphicRowTile(x=x, graphic=graphic)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_item.py

@@ -13,12 +13,31 @@ class MapItem:
     Item spawn EMF entity
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
-    _key: int = None # type: ignore [assignment]
-    _chest_slot: int = None # type: ignore [assignment]
-    _item_id: int = None # type: ignore [assignment]
-    _spawn_time: int = None # type: ignore [assignment]
-    _amount: int = None # type: ignore [assignment]
+    _coords: Coords
+    _key: int
+    _chest_slot: int
+    _item_id: int
+    _spawn_time: int
+    _amount: int
+
+    def __init__(self, *, coords: Coords, key: int, chest_slot: int, item_id: int, spawn_time: int, amount: int):
+        """
+        Create a new instance of MapItem.
+
+        Args:
+            coords (Coords): 
+            key (int): (Value range is 0-64008.)
+            chest_slot (int): (Value range is 0-252.)
+            item_id (int): (Value range is 0-64008.)
+            spawn_time (int): (Value range is 0-64008.)
+            amount (int): (Value range is 0-16194276.)
+        """
+        self._coords = coords
+        self._key = key
+        self._chest_slot = chest_slot
+        self._item_id = item_id
+        self._spawn_time = spawn_time
+        self._amount = amount
 
     @property
     def byte_size(self) -> int:
@@ -34,90 +53,26 @@ class MapItem:
     def coords(self) -> Coords:
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @property
     def key(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._key
 
-    @key.setter
-    def key(self, key: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._key = key
-
     @property
     def chest_slot(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._chest_slot
 
-    @chest_slot.setter
-    def chest_slot(self, chest_slot: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._chest_slot = chest_slot
-
     @property
     def item_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._item_id
 
-    @item_id.setter
-    def item_id(self, item_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._item_id = item_id
-
     @property
     def spawn_time(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._spawn_time
 
-    @spawn_time.setter
-    def spawn_time(self, spawn_time: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._spawn_time = spawn_time
-
     @property
     def amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._amount
 
-    @amount.setter
-    def amount(self, amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._amount = amount
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapItem") -> None:
         """
@@ -161,18 +116,18 @@ class MapItem:
         Returns:
             MapItem: The data to serialize.
         """
-        data: MapItem = MapItem()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            data._key = reader.get_short()
-            data._chest_slot = reader.get_char()
-            data._item_id = reader.get_short()
-            data._spawn_time = reader.get_short()
-            data._amount = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            key = reader.get_short()
+            chest_slot = reader.get_char()
+            item_id = reader.get_short()
+            spawn_time = reader.get_short()
+            amount = reader.get_three()
+            result = MapItem(coords=coords, key=key, chest_slot=chest_slot, item_id=item_id, spawn_time=spawn_time, amount=amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_legacy_door_key.py

@@ -13,8 +13,19 @@ class MapLegacyDoorKey:
     Legacy EMF entity used to specify a key on a door
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
-    _key: int = None # type: ignore [assignment]
+    _coords: Coords
+    _key: int
+
+    def __init__(self, *, coords: Coords, key: int):
+        """
+        Create a new instance of MapLegacyDoorKey.
+
+        Args:
+            coords (Coords): 
+            key (int): (Value range is 0-64008.)
+        """
+        self._coords = coords
+        self._key = key
 
     @property
     def byte_size(self) -> int:
@@ -30,26 +41,10 @@ class MapLegacyDoorKey:
     def coords(self) -> Coords:
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @property
     def key(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._key
 
-    @key.setter
-    def key(self, key: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._key = key
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapLegacyDoorKey") -> None:
         """
@@ -81,14 +76,14 @@ class MapLegacyDoorKey:
         Returns:
             MapLegacyDoorKey: The data to serialize.
         """
-        data: MapLegacyDoorKey = MapLegacyDoorKey()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            data._key = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            key = reader.get_short()
+            result = MapLegacyDoorKey(coords=coords, key=key)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_npc.py

@@ -13,11 +13,28 @@ class MapNpc:
     NPC spawn EMF entity
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
-    _id: int = None # type: ignore [assignment]
-    _spawn_type: int = None # type: ignore [assignment]
-    _spawn_time: int = None # type: ignore [assignment]
-    _amount: int = None # type: ignore [assignment]
+    _coords: Coords
+    _id: int
+    _spawn_type: int
+    _spawn_time: int
+    _amount: int
+
+    def __init__(self, *, coords: Coords, id: int, spawn_type: int, spawn_time: int, amount: int):
+        """
+        Create a new instance of MapNpc.
+
+        Args:
+            coords (Coords): 
+            id (int): (Value range is 0-64008.)
+            spawn_type (int): (Value range is 0-252.)
+            spawn_time (int): (Value range is 0-64008.)
+            amount (int): (Value range is 0-252.)
+        """
+        self._coords = coords
+        self._id = id
+        self._spawn_type = spawn_type
+        self._spawn_time = spawn_time
+        self._amount = amount
 
     @property
     def byte_size(self) -> int:
@@ -33,74 +50,22 @@ class MapNpc:
     def coords(self) -> Coords:
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @property
     def id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._id
 
-    @id.setter
-    def id(self, id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._id = id
-
     @property
     def spawn_type(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._spawn_type
 
-    @spawn_type.setter
-    def spawn_type(self, spawn_type: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._spawn_type = spawn_type
-
     @property
     def spawn_time(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._spawn_time
 
-    @spawn_time.setter
-    def spawn_time(self, spawn_time: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._spawn_time = spawn_time
-
     @property
     def amount(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._amount
 
-    @amount.setter
-    def amount(self, amount: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._amount = amount
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapNpc") -> None:
         """
@@ -141,17 +106,17 @@ class MapNpc:
         Returns:
             MapNpc: The data to serialize.
         """
-        data: MapNpc = MapNpc()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            data._id = reader.get_short()
-            data._spawn_type = reader.get_char()
-            data._spawn_time = reader.get_short()
-            data._amount = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            id = reader.get_short()
+            spawn_type = reader.get_char()
+            spawn_time = reader.get_short()
+            amount = reader.get_char()
+            result = MapNpc(coords=coords, id=id, spawn_type=spawn_type, spawn_time=spawn_time, amount=amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode