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

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:
         """
@@ -110,21 +75,25 @@ class MapNpc:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapNpc): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._spawn_type is None:
-            raise SerializationError("spawn_type must be provided.")
-        writer.add_char(data._spawn_type)
-        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_char(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._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._spawn_type is None:
+                raise SerializationError("spawn_type must be provided.")
+            writer.add_char(data._spawn_type)
+            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_char(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapNpc":
@@ -137,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
 

eolib/protocol/_generated/map/map_sign.py

@@ -13,10 +13,24 @@ class MapSign:
     Sign EMF entity
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
-    _string_data_length: int = None # type: ignore [assignment]
-    _string_data: str = None # type: ignore [assignment]
-    _title_length: int = None # type: ignore [assignment]
+    _coords: Coords
+    _string_data_length: int
+    _string_data: str
+    _title_length: int
+
+    def __init__(self, *, coords: Coords, string_data: str, title_length: int):
+        """
+        Create a new instance of MapSign.
+
+        Args:
+            coords (Coords): 
+            string_data (str): (Length must be 64007 or less.)
+            title_length (int): (Value range is 0-252.)
+        """
+        self._coords = coords
+        self._string_data = string_data
+        self._string_data_length = len(self._string_data)
+        self._title_length = title_length
 
     @property
     def byte_size(self) -> int:
@@ -32,43 +46,14 @@ class MapSign:
     def coords(self) -> Coords:
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @property
     def string_data(self) -> str:
-        """
-        Note:
-          - Length must be 64007 or less.
-        """
         return self._string_data
 
-    @string_data.setter
-    def string_data(self, string_data: str) -> None:
-        """
-        Note:
-          - Length must be 64007 or less.
-        """
-        self._string_data = string_data
-        self._string_data_length = len(self._string_data)
-
     @property
     def title_length(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._title_length
 
-    @title_length.setter
-    def title_length(self, title_length: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._title_length = title_length
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapSign") -> None:
         """
@@ -78,20 +63,24 @@ class MapSign:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapSign): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._string_data_length is None:
-            raise SerializationError("string_data_length must be provided.")
-        writer.add_short(data._string_data_length + 1)
-        if data._string_data is None:
-            raise SerializationError("string_data must be provided.")
-        if len(data._string_data) > 64007:
-            raise SerializationError(f"Expected length of string_data to be 64007 or less, got {len(data._string_data)}.")
-        writer.add_fixed_encoded_string(data._string_data, data._string_data_length, False)
-        if data._title_length is None:
-            raise SerializationError("title_length must be provided.")
-        writer.add_char(data._title_length)
+        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._string_data_length is None:
+                raise SerializationError("string_data_length must be provided.")
+            writer.add_short(data._string_data_length + 1)
+            if data._string_data is None:
+                raise SerializationError("string_data must be provided.")
+            if len(data._string_data) > 64007:
+                raise SerializationError(f"Expected length of string_data to be 64007 or less, got {len(data._string_data)}.")
+            writer.add_fixed_encoded_string(data._string_data, data._string_data_length, False)
+            if data._title_length is None:
+                raise SerializationError("title_length must be provided.")
+            writer.add_char(data._title_length)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapSign":
@@ -104,16 +93,16 @@ class MapSign:
         Returns:
             MapSign: The data to serialize.
         """
-        data: MapSign = MapSign()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            data._string_data_length = reader.get_short() - 1
-            data._string_data = reader.get_fixed_encoded_string(data._string_data_length, False)
-            data._title_length = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            string_data_length = reader.get_short() - 1
+            string_data = reader.get_fixed_encoded_string(string_data_length, False)
+            title_length = reader.get_char()
+            result = MapSign(coords=coords, string_data=string_data, title_length=title_length)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_tile_spec_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_tile_spec_row_tile import MapTileSpecRowTile
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,9 +15,21 @@ class MapTileSpecRow:
     A row of tilespecs
     """
     _byte_size: int = 0
-    _y: int = None # type: ignore [assignment]
-    _tiles_count: int = None # type: ignore [assignment]
-    _tiles: list[MapTileSpecRowTile] = None # type: ignore [assignment]
+    _y: int
+    _tiles_count: int
+    _tiles: tuple[MapTileSpecRowTile, ...]
+
+    def __init__(self, *, y: int, tiles: Iterable[MapTileSpecRowTile]):
+        """
+        Create a new instance of MapTileSpecRow.
+
+        Args:
+            y (int): (Value range is 0-252.)
+            tiles (Iterable[MapTileSpecRowTile]): (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 MapTileSpecRow:
 
     @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[MapTileSpecRowTile]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def tiles(self) -> tuple[MapTileSpecRowTile, ...]:
         return self._tiles
 
-    @tiles.setter
-    def tiles(self, tiles: list[MapTileSpecRowTile]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._tiles = tiles
-        self._tiles_count = len(self._tiles)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapTileSpecRow") -> None:
         """
@@ -70,18 +58,22 @@ class MapTileSpecRow:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapTileSpecRow): 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):
-            MapTileSpecRowTile.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):
+                MapTileSpecRowTile.serialize(writer, data._tiles[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapTileSpecRow":
@@ -94,17 +86,17 @@ class MapTileSpecRow:
         Returns:
             MapTileSpecRow: The data to serialize.
         """
-        data: MapTileSpecRow = MapTileSpecRow()
         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(MapTileSpecRowTile.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(MapTileSpecRowTile.deserialize(reader))
+            result = MapTileSpecRow(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_tile_spec_row_tile.py

@@ -13,8 +13,19 @@ class MapTileSpecRowTile:
     A single tile in a row of tilespecs
     """
     _byte_size: int = 0
-    _x: int = None # type: ignore [assignment]
-    _tile_spec: MapTileSpec = None # type: ignore [assignment]
+    _x: int
+    _tile_spec: MapTileSpec
+
+    def __init__(self, *, x: int, tile_spec: MapTileSpec):
+        """
+        Create a new instance of MapTileSpecRowTile.
+
+        Args:
+            x (int): (Value range is 0-252.)
+            tile_spec (MapTileSpec): 
+        """
+        self._x = x
+        self._tile_spec = tile_spec
 
     @property
     def byte_size(self) -> int:
@@ -28,28 +39,12 @@ class MapTileSpecRowTile:
 
     @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 tile_spec(self) -> MapTileSpec:
         return self._tile_spec
 
-    @tile_spec.setter
-    def tile_spec(self, tile_spec: MapTileSpec) -> None:
-        self._tile_spec = tile_spec
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapTileSpecRowTile") -> None:
         """
@@ -59,12 +54,16 @@ class MapTileSpecRowTile:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapTileSpecRowTile): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_char(data._x)
-        if data._tile_spec is None:
-            raise SerializationError("tile_spec must be provided.")
-        writer.add_char(int(data._tile_spec))
+        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._tile_spec is None:
+                raise SerializationError("tile_spec must be provided.")
+            writer.add_char(int(data._tile_spec))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapTileSpecRowTile":
@@ -77,14 +76,14 @@ class MapTileSpecRowTile:
         Returns:
             MapTileSpecRowTile: The data to serialize.
         """
-        data: MapTileSpecRowTile = MapTileSpecRowTile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._x = reader.get_char()
-            data._tile_spec = MapTileSpec(reader.get_char())
-            data._byte_size = reader.position - reader_start_position
-            return data
+            x = reader.get_char()
+            tile_spec = MapTileSpec(reader.get_char())
+            result = MapTileSpecRowTile(x=x, tile_spec=tile_spec)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode