eolib 1.1.1__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:
         """
@@ -53,15 +51,19 @@ class MapGraphicLayer:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapGraphicLayer): The data to serialize.
         """
-        if data._graphic_rows_count is None:
-            raise SerializationError("graphic_rows_count must be provided.")
-        writer.add_char(data._graphic_rows_count)
-        if data._graphic_rows is None:
-            raise SerializationError("graphic_rows must be provided.")
-        if len(data._graphic_rows) > 252:
-            raise SerializationError(f"Expected length of graphic_rows to be 252 or less, got {len(data._graphic_rows)}.")
-        for i in range(data._graphic_rows_count):
-            MapGraphicRow.serialize(writer, data._graphic_rows[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._graphic_rows_count is None:
+                raise SerializationError("graphic_rows_count must be provided.")
+            writer.add_char(data._graphic_rows_count)
+            if data._graphic_rows is None:
+                raise SerializationError("graphic_rows must be provided.")
+            if len(data._graphic_rows) > 252:
+                raise SerializationError(f"Expected length of graphic_rows to be 252 or less, got {len(data._graphic_rows)}.")
+            for i in range(data._graphic_rows_count):
+                MapGraphicRow.serialize(writer, data._graphic_rows[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapGraphicLayer":
@@ -74,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:
         """
@@ -70,18 +58,22 @@ class MapGraphicRow:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapGraphicRow): The data to serialize.
         """
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_char(data._y)
-        if data._tiles_count is None:
-            raise SerializationError("tiles_count must be provided.")
-        writer.add_char(data._tiles_count)
-        if data._tiles is None:
-            raise SerializationError("tiles must be provided.")
-        if len(data._tiles) > 252:
-            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
-        for i in range(data._tiles_count):
-            MapGraphicRowTile.serialize(writer, data._tiles[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_char(data._y)
+            if data._tiles_count is None:
+                raise SerializationError("tiles_count must be provided.")
+            writer.add_char(data._tiles_count)
+            if data._tiles is None:
+                raise SerializationError("tiles must be provided.")
+            if len(data._tiles) > 252:
+                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
+            for i in range(data._tiles_count):
+                MapGraphicRowTile.serialize(writer, data._tiles[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapGraphicRow":
@@ -94,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:
         """
@@ -66,12 +53,16 @@ class MapGraphicRowTile:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapGraphicRowTile): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_char(data._x)
-        if data._graphic is None:
-            raise SerializationError("graphic must be provided.")
-        writer.add_short(data._graphic)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._x is None:
+                raise SerializationError("x must be provided.")
+            writer.add_char(data._x)
+            if data._graphic is None:
+                raise SerializationError("graphic must be provided.")
+            writer.add_short(data._graphic)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapGraphicRowTile":
@@ -84,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:
         """
@@ -127,24 +82,28 @@ class MapItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapItem): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._key is None:
-            raise SerializationError("key must be provided.")
-        writer.add_short(data._key)
-        if data._chest_slot is None:
-            raise SerializationError("chest_slot must be provided.")
-        writer.add_char(data._chest_slot)
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._spawn_time is None:
-            raise SerializationError("spawn_time must be provided.")
-        writer.add_short(data._spawn_time)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_three(data._amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._key is None:
+                raise SerializationError("key must be provided.")
+            writer.add_short(data._key)
+            if data._chest_slot is None:
+                raise SerializationError("chest_slot must be provided.")
+            writer.add_char(data._chest_slot)
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._spawn_time is None:
+                raise SerializationError("spawn_time must be provided.")
+            writer.add_short(data._spawn_time)
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_three(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapItem":
@@ -157,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:
         """
@@ -59,12 +54,16 @@ class MapLegacyDoorKey:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapLegacyDoorKey): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._key is None:
-            raise SerializationError("key must be provided.")
-        writer.add_short(data._key)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._key is None:
+                raise SerializationError("key must be provided.")
+            writer.add_short(data._key)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapLegacyDoorKey":
@@ -77,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