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

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:
         """
@@ -108,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:
         """
@@ -98,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:
         """
@@ -81,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
 

eolib/protocol/_generated/map/map_warp.py

@@ -13,10 +13,25 @@ class MapWarp:
     Warp EMF entity
     """
     _byte_size: int = 0
-    _destination_map: int = None # type: ignore [assignment]
-    _destination_coords: Coords = None # type: ignore [assignment]
-    _level_required: int = None # type: ignore [assignment]
-    _door: int = None # type: ignore [assignment]
+    _destination_map: int
+    _destination_coords: Coords
+    _level_required: int
+    _door: int
+
+    def __init__(self, *, destination_map: int, destination_coords: Coords, level_required: int, door: int):
+        """
+        Create a new instance of MapWarp.
+
+        Args:
+            destination_map (int): (Value range is 0-64008.)
+            destination_coords (Coords): 
+            level_required (int): (Value range is 0-252.)
+            door (int): (Value range is 0-64008.)
+        """
+        self._destination_map = destination_map
+        self._destination_coords = destination_coords
+        self._level_required = level_required
+        self._door = door
 
     @property
     def byte_size(self) -> int:
@@ -30,60 +45,20 @@ class MapWarp:
 
     @property
     def destination_map(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._destination_map
 
-    @destination_map.setter
-    def destination_map(self, destination_map: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._destination_map = destination_map
-
     @property
     def destination_coords(self) -> Coords:
         return self._destination_coords
 
-    @destination_coords.setter
-    def destination_coords(self, destination_coords: Coords) -> None:
-        self._destination_coords = destination_coords
-
     @property
     def level_required(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._level_required
 
-    @level_required.setter
-    def level_required(self, level_required: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._level_required = level_required
-
     @property
     def door(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._door
 
-    @door.setter
-    def door(self, door: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._door = door
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapWarp") -> None:
         """
@@ -121,16 +96,16 @@ class MapWarp:
         Returns:
             MapWarp: The data to serialize.
         """
-        data: MapWarp = MapWarp()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._destination_map = reader.get_short()
-            data._destination_coords = Coords.deserialize(reader)
-            data._level_required = reader.get_char()
-            data._door = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            destination_map = reader.get_short()
+            destination_coords = Coords.deserialize(reader)
+            level_required = reader.get_char()
+            door = reader.get_short()
+            result = MapWarp(destination_map=destination_map, destination_coords=destination_coords, level_required=level_required, door=door)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/map/map_warp_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_warp_row_tile import MapWarpRowTile
 from ...serialization_error import SerializationError
 from ....data.eo_writer import EoWriter
@@ -14,9 +15,21 @@ class MapWarpRow:
     A row of warp entities
     """
     _byte_size: int = 0
-    _y: int = None # type: ignore [assignment]
-    _tiles_count: int = None # type: ignore [assignment]
-    _tiles: list[MapWarpRowTile] = None # type: ignore [assignment]
+    _y: int
+    _tiles_count: int
+    _tiles: tuple[MapWarpRowTile, ...]
+
+    def __init__(self, *, y: int, tiles: Iterable[MapWarpRowTile]):
+        """
+        Create a new instance of MapWarpRow.
+
+        Args:
+            y (int): (Value range is 0-252.)
+            tiles (Iterable[MapWarpRowTile]): (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 MapWarpRow:
 
     @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[MapWarpRowTile]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def tiles(self) -> tuple[MapWarpRowTile, ...]:
         return self._tiles
 
-    @tiles.setter
-    def tiles(self, tiles: list[MapWarpRowTile]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._tiles = tiles
-        self._tiles_count = len(self._tiles)
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapWarpRow") -> None:
         """
@@ -98,17 +86,17 @@ class MapWarpRow:
         Returns:
             MapWarpRow: The data to serialize.
         """
-        data: MapWarpRow = MapWarpRow()
         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(MapWarpRowTile.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(MapWarpRowTile.deserialize(reader))
+            result = MapWarpRow(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_warp_row_tile.py

@@ -13,8 +13,19 @@ class MapWarpRowTile:
     A single tile in a row of warp entities
     """
     _byte_size: int = 0
-    _x: int = None # type: ignore [assignment]
-    _warp: MapWarp = None # type: ignore [assignment]
+    _x: int
+    _warp: MapWarp
+
+    def __init__(self, *, x: int, warp: MapWarp):
+        """
+        Create a new instance of MapWarpRowTile.
+
+        Args:
+            x (int): (Value range is 0-252.)
+            warp (MapWarp): 
+        """
+        self._x = x
+        self._warp = warp
 
     @property
     def byte_size(self) -> int:
@@ -28,28 +39,12 @@ class MapWarpRowTile:
 
     @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 warp(self) -> MapWarp:
         return self._warp
 
-    @warp.setter
-    def warp(self, warp: MapWarp) -> None:
-        self._warp = warp
-
     @staticmethod
     def serialize(writer: EoWriter, data: "MapWarpRowTile") -> None:
         """
@@ -81,14 +76,14 @@ class MapWarpRowTile:
         Returns:
             MapWarpRowTile: The data to serialize.
         """
-        data: MapWarpRowTile = MapWarpRowTile()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._x = reader.get_char()
-            data._warp = MapWarp.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            x = reader.get_char()
+            warp = MapWarp.deserialize(reader)
+            result = MapWarpRowTile(x=x, warp=warp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/char_item.py

@@ -13,8 +13,19 @@ class CharItem:
     Used for craft ingredients.
     """
     _byte_size: int = 0
-    _id: int = None # type: ignore [assignment]
-    _amount: int = None # type: ignore [assignment]
+    _id: int
+    _amount: int
+
+    def __init__(self, *, id: int, amount: int):
+        """
+        Create a new instance of CharItem.
+
+        Args:
+            id (int): (Value range is 0-64008.)
+            amount (int): (Value range is 0-252.)
+        """
+        self._id = id
+        self._amount = amount
 
     @property
     def byte_size(self) -> int:
@@ -28,36 +39,12 @@ class CharItem:
 
     @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 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: "CharItem") -> None:
         """
@@ -89,14 +76,14 @@ class CharItem:
         Returns:
             CharItem: The data to serialize.
         """
-        data: CharItem = CharItem()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._id = reader.get_short()
-            data._amount = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            id = reader.get_short()
+            amount = reader.get_char()
+            result = CharItem(id=id, amount=amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode