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

eolib/protocol/_generated/net/server/walk_close_server_packet.py

@@ -15,6 +15,11 @@ class WalkCloseServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of WalkCloseServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -80,13 +85,13 @@ class WalkCloseServerPacket(Packet):
         Returns:
             WalkCloseServerPacket: The data to serialize.
         """
-        data: WalkCloseServerPacket = WalkCloseServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = WalkCloseServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/walk_open_server_packet.py

@@ -15,6 +15,11 @@ class WalkOpenServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of WalkOpenServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -80,13 +85,13 @@ class WalkOpenServerPacket(Packet):
         Returns:
             WalkOpenServerPacket: The data to serialize.
         """
-        data: WalkOpenServerPacket = WalkOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = WalkOpenServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/walk_player_server_packet.py

@@ -3,7 +3,6 @@
 # This file should not be modified.
 # Changes will be lost when code is regenerated.
 
-from warnings import warn
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
 from ...direction import Direction
@@ -18,9 +17,22 @@ class WalkPlayerServerPacket(Packet):
     Nearby player has walked
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _direction: Direction = None # type: ignore [assignment]
-    _coords: Coords = None # type: ignore [assignment]
+    _player_id: int
+    _direction: Direction
+    _coords: Coords
+
+    def __init__(self, *, player_id: int, direction: Direction, coords: Coords):
+        """
+        Create a new instance of WalkPlayerServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            direction (Direction): 
+            coords (Coords): 
+        """
+        self._player_id = player_id
+        self._direction = direction
+        self._coords = coords
 
     @property
     def byte_size(self) -> int:
@@ -34,55 +46,16 @@ class WalkPlayerServerPacket(Packet):
 
     @property
     def player_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._player_id
 
-    @player_id.setter
-    def player_id(self, player_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._player_id = player_id
-
     @property
     def direction(self) -> Direction:
         return self._direction
 
-    @direction.setter
-    def direction(self, direction: Direction) -> None:
-        self._direction = direction
-
-    @property
-    def Direction(self) -> Direction:
-        """
-        !!! warning "Deprecated"
-
-            Use `direction` instead. (Deprecated since v1.1.0)
-        """
-        warn("'WalkPlayerServerPacket.Direction' is deprecated as of 1.1.0, use 'direction' instead.", DeprecationWarning, stacklevel=2)
-        return self.direction
-
-    @Direction.setter
-    def Direction(self, direction: Direction) -> None:
-        """
-        !!! warning "Deprecated"
-
-            Use `direction` instead. (Deprecated since v1.1.0)
-        """
-        self.direction = direction
-
     @property
     def coords(self) -> Coords:
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -146,15 +119,15 @@ class WalkPlayerServerPacket(Packet):
         Returns:
             WalkPlayerServerPacket: The data to serialize.
         """
-        data: WalkPlayerServerPacket = WalkPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._direction = Direction(reader.get_char())
-            data._coords = Coords.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            direction = Direction(reader.get_char())
+            coords = Coords.deserialize(reader)
+            result = WalkPlayerServerPacket(player_id=player_id, direction=direction, coords=coords)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/walk_reply_server_packet.py

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .item_map_info import ItemMapInfo
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,9 +18,22 @@ class WalkReplyServerPacket(Packet):
     Players, NPCs, and Items appearing in nearby view
     """
     _byte_size: int = 0
-    _player_ids: list[int] = None # type: ignore [assignment]
-    _npc_indexes: list[int] = None # type: ignore [assignment]
-    _items: list[ItemMapInfo] = None # type: ignore [assignment]
+    _player_ids: tuple[int, ...]
+    _npc_indexes: tuple[int, ...]
+    _items: tuple[ItemMapInfo, ...]
+
+    def __init__(self, *, player_ids: Iterable[int], npc_indexes: Iterable[int], items: Iterable[ItemMapInfo]):
+        """
+        Create a new instance of WalkReplyServerPacket.
+
+        Args:
+            player_ids (Iterable[int]): (Element value range is 0-64008.)
+            npc_indexes (Iterable[int]): (Element value range is 0-252.)
+            items (Iterable[ItemMapInfo]): 
+        """
+        self._player_ids = tuple(player_ids)
+        self._npc_indexes = tuple(npc_indexes)
+        self._items = tuple(items)
 
     @property
     def byte_size(self) -> int:
@@ -32,45 +46,17 @@ class WalkReplyServerPacket(Packet):
         return self._byte_size
 
     @property
-    def player_ids(self) -> list[int]:
-        """
-        Note:
-          - Element value range is 0-64008.
-        """
+    def player_ids(self) -> tuple[int, ...]:
         return self._player_ids
 
-    @player_ids.setter
-    def player_ids(self, player_ids: list[int]) -> None:
-        """
-        Note:
-          - Element value range is 0-64008.
-        """
-        self._player_ids = player_ids
-
     @property
-    def npc_indexes(self) -> list[int]:
-        """
-        Note:
-          - Element value range is 0-252.
-        """
+    def npc_indexes(self) -> tuple[int, ...]:
         return self._npc_indexes
 
-    @npc_indexes.setter
-    def npc_indexes(self, npc_indexes: list[int]) -> None:
-        """
-        Note:
-          - Element value range is 0-252.
-        """
-        self._npc_indexes = npc_indexes
-
     @property
-    def items(self) -> list[ItemMapInfo]:
+    def items(self) -> tuple[ItemMapInfo, ...]:
         return self._items
 
-    @items.setter
-    def items(self, items: list[ItemMapInfo]) -> None:
-        self._items = items
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -141,28 +127,28 @@ class WalkReplyServerPacket(Packet):
         Returns:
             WalkReplyServerPacket: The data to serialize.
         """
-        data: WalkReplyServerPacket = WalkReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
             player_ids_length = int(reader.remaining / 2)
-            data._player_ids = []
+            player_ids = []
             for i in range(player_ids_length):
-                data._player_ids.append(reader.get_short())
+                player_ids.append(reader.get_short())
             reader.next_chunk()
             npc_indexes_length = int(reader.remaining / 1)
-            data._npc_indexes = []
+            npc_indexes = []
             for i in range(npc_indexes_length):
-                data._npc_indexes.append(reader.get_char())
+                npc_indexes.append(reader.get_char())
             reader.next_chunk()
             items_length = int(reader.remaining / 9)
-            data._items = []
+            items = []
             for i in range(items_length):
-                data._items.append(ItemMapInfo.deserialize(reader))
+                items.append(ItemMapInfo.deserialize(reader))
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = WalkReplyServerPacket(player_ids=player_ids, npc_indexes=npc_indexes, items=items)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/warp_agree_server_packet.py

@@ -19,9 +19,22 @@ class WarpAgreeServerPacket(Packet):
     Reply after accepting a warp
     """
     _byte_size: int = 0
-    _warp_type: WarpType = None # type: ignore [assignment]
-    _warp_type_data: 'WarpAgreeServerPacket.WarpTypeData' = None
-    _nearby: NearbyInfo = None # type: ignore [assignment]
+    _warp_type: WarpType
+    _warp_type_data: 'WarpAgreeServerPacket.WarpTypeData'
+    _nearby: NearbyInfo
+
+    def __init__(self, *, warp_type: WarpType, warp_type_data: 'WarpAgreeServerPacket.WarpTypeData' = None, nearby: NearbyInfo):
+        """
+        Create a new instance of WarpAgreeServerPacket.
+
+        Args:
+            warp_type (WarpType): 
+            warp_type_data (WarpAgreeServerPacket.WarpTypeData): Data associated with the `warp_type` field.
+            nearby (NearbyInfo): 
+        """
+        self._warp_type = warp_type
+        self._warp_type_data = warp_type_data
+        self._nearby = nearby
 
     @property
     def byte_size(self) -> int:
@@ -37,29 +50,17 @@ class WarpAgreeServerPacket(Packet):
     def warp_type(self) -> WarpType:
         return self._warp_type
 
-    @warp_type.setter
-    def warp_type(self, warp_type: WarpType) -> None:
-        self._warp_type = warp_type
-
     @property
     def warp_type_data(self) -> 'WarpAgreeServerPacket.WarpTypeData':
         """
-        WarpAgreeServerPacket.WarpTypeData: Gets or sets the data associated with the `warp_type` field.
+        WarpAgreeServerPacket.WarpTypeData: Data associated with the `warp_type` field.
         """
         return self._warp_type_data
 
-    @warp_type_data.setter
-    def warp_type_data(self, warp_type_data: 'WarpAgreeServerPacket.WarpTypeData') -> None:
-        self._warp_type_data = warp_type_data
-
     @property
     def nearby(self) -> NearbyInfo:
         return self._nearby
 
-    @nearby.setter
-    def nearby(self, nearby: NearbyInfo) -> None:
-        self._nearby = nearby
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -126,18 +127,19 @@ class WarpAgreeServerPacket(Packet):
         Returns:
             WarpAgreeServerPacket: The data to serialize.
         """
-        data: WarpAgreeServerPacket = WarpAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._warp_type = WarpType(reader.get_char())
-            if data._warp_type == WarpType.MapSwitch:
-                data._warp_type_data = WarpAgreeServerPacket.WarpTypeDataMapSwitch.deserialize(reader)
-            data._nearby = NearbyInfo.deserialize(reader)
+            warp_type = WarpType(reader.get_char())
+            warp_type_data: WarpAgreeServerPacket.WarpTypeData = None
+            if warp_type == WarpType.MapSwitch:
+                warp_type_data = WarpAgreeServerPacket.WarpTypeDataMapSwitch.deserialize(reader)
+            nearby = NearbyInfo.deserialize(reader)
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = WarpAgreeServerPacket(warp_type=warp_type, warp_type_data=warp_type_data, nearby=nearby)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -154,8 +156,19 @@ class WarpAgreeServerPacket(Packet):
         Data associated with warp_type value WarpType.MapSwitch
         """
         _byte_size: int = 0
-        _map_id: int = None # type: ignore [assignment]
-        _warp_effect: WarpEffect = None # type: ignore [assignment]
+        _map_id: int
+        _warp_effect: WarpEffect
+
+        def __init__(self, *, map_id: int, warp_effect: WarpEffect):
+            """
+            Create a new instance of WarpAgreeServerPacket.WarpTypeDataMapSwitch.
+
+            Args:
+                map_id (int): (Value range is 0-64008.)
+                warp_effect (WarpEffect): 
+            """
+            self._map_id = map_id
+            self._warp_effect = warp_effect
 
         @property
         def byte_size(self) -> int:
@@ -169,28 +182,12 @@ class WarpAgreeServerPacket(Packet):
 
         @property
         def map_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._map_id
 
-        @map_id.setter
-        def map_id(self, map_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._map_id = map_id
-
         @property
         def warp_effect(self) -> WarpEffect:
             return self._warp_effect
 
-        @warp_effect.setter
-        def warp_effect(self, warp_effect: WarpEffect) -> None:
-            self._warp_effect = warp_effect
-
         @staticmethod
         def serialize(writer: EoWriter, data: "WarpAgreeServerPacket.WarpTypeDataMapSwitch") -> None:
             """
@@ -222,14 +219,14 @@ class WarpAgreeServerPacket(Packet):
             Returns:
                 WarpAgreeServerPacket.WarpTypeDataMapSwitch: The data to serialize.
             """
-            data: WarpAgreeServerPacket.WarpTypeDataMapSwitch = WarpAgreeServerPacket.WarpTypeDataMapSwitch()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._map_id = reader.get_short()
-                data._warp_effect = WarpEffect(reader.get_char())
-                data._byte_size = reader.position - reader_start_position
-                return data
+                map_id = reader.get_short()
+                warp_effect = WarpEffect(reader.get_char())
+                result = WarpAgreeServerPacket.WarpTypeDataMapSwitch(map_id=map_id, warp_effect=warp_effect)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/warp_create_server_packet.py

@@ -16,7 +16,16 @@ class WarpCreateServerPacket(Packet):
     Equivalent to INIT_INIT with InitReply.MapMutation
     """
     _byte_size: int = 0
-    _map_file: MapFile = None # type: ignore [assignment]
+    _map_file: MapFile
+
+    def __init__(self, *, map_file: MapFile):
+        """
+        Create a new instance of WarpCreateServerPacket.
+
+        Args:
+            map_file (MapFile): 
+        """
+        self._map_file = map_file
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class WarpCreateServerPacket(Packet):
     def map_file(self) -> MapFile:
         return self._map_file
 
-    @map_file.setter
-    def map_file(self, map_file: MapFile) -> None:
-        self._map_file = map_file
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -93,13 +98,13 @@ class WarpCreateServerPacket(Packet):
         Returns:
             WarpCreateServerPacket: The data to serialize.
         """
-        data: WarpCreateServerPacket = WarpCreateServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._map_file = MapFile.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            map_file = MapFile.deserialize(reader)
+            result = WarpCreateServerPacket(map_file=map_file)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/warp_player_server_packet.py

@@ -16,7 +16,16 @@ class WarpPlayerServerPacket(Packet):
     Equivalent to INIT_INIT with InitReply.WarpMap
     """
     _byte_size: int = 0
-    _map_file: MapFile = None # type: ignore [assignment]
+    _map_file: MapFile
+
+    def __init__(self, *, map_file: MapFile):
+        """
+        Create a new instance of WarpPlayerServerPacket.
+
+        Args:
+            map_file (MapFile): 
+        """
+        self._map_file = map_file
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class WarpPlayerServerPacket(Packet):
     def map_file(self) -> MapFile:
         return self._map_file
 
-    @map_file.setter
-    def map_file(self, map_file: MapFile) -> None:
-        self._map_file = map_file
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -93,13 +98,13 @@ class WarpPlayerServerPacket(Packet):
         Returns:
             WarpPlayerServerPacket: The data to serialize.
         """
-        data: WarpPlayerServerPacket = WarpPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._map_file = MapFile.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            map_file = MapFile.deserialize(reader)
+            result = WarpPlayerServerPacket(map_file=map_file)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode