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

eolib/protocol/_generated/net/server/quest_report_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 ..packet_family import PacketFamily
 from ..packet_action import PacketAction
 from ....serialization_error import SerializationError
@@ -16,8 +17,19 @@ class QuestReportServerPacket(Packet):
     NPC chat messages
     """
     _byte_size: int = 0
-    _npc_id: int = None # type: ignore [assignment]
-    _messages: list[str] = None # type: ignore [assignment]
+    _npc_index: int
+    _messages: tuple[str, ...]
+
+    def __init__(self, *, npc_index: int, messages: Iterable[str]):
+        """
+        Create a new instance of QuestReportServerPacket.
+
+        Args:
+            npc_index (int): (Value range is 0-64008.)
+            messages (Iterable[str]): 
+        """
+        self._npc_index = npc_index
+        self._messages = tuple(messages)
 
     @property
     def byte_size(self) -> int:
@@ -30,29 +42,13 @@ class QuestReportServerPacket(Packet):
         return self._byte_size
 
     @property
-    def npc_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        return self._npc_id
-
-    @npc_id.setter
-    def npc_id(self, npc_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._npc_id = npc_id
+    def npc_index(self) -> int:
+        return self._npc_index
 
     @property
-    def messages(self) -> list[str]:
+    def messages(self) -> tuple[str, ...]:
         return self._messages
 
-    @messages.setter
-    def messages(self, messages: list[str]) -> None:
-        self._messages = messages
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -94,9 +90,9 @@ class QuestReportServerPacket(Packet):
         old_string_sanitization_mode: bool = writer.string_sanitization_mode
         try:
             writer.string_sanitization_mode = True
-            if data._npc_id is None:
-                raise SerializationError("npc_id must be provided.")
-            writer.add_short(data._npc_id)
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
             writer.add_byte(0xFF)
             if data._messages is None:
                 raise SerializationError("messages must be provided.")
@@ -118,22 +114,22 @@ class QuestReportServerPacket(Packet):
         Returns:
             QuestReportServerPacket: The data to serialize.
         """
-        data: QuestReportServerPacket = QuestReportServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._npc_id = reader.get_short()
+            npc_index = reader.get_short()
             reader.next_chunk()
-            data._messages = []
+            messages = []
             while reader.remaining > 0:
-                data._messages.append(reader.get_string())
+                messages.append(reader.get_string())
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = QuestReportServerPacket(npc_index=npc_index, messages=messages)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
     def __repr__(self):
-        return f"QuestReportServerPacket(byte_size={repr(self._byte_size)}, npc_id={repr(self._npc_id)}, messages={repr(self._messages)})"
+        return f"QuestReportServerPacket(byte_size={repr(self._byte_size)}, npc_index={repr(self._npc_index)}, messages={repr(self._messages)})"

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

@@ -16,7 +16,16 @@ class RangeReplyServerPacket(Packet):
     Reply to request for information about nearby players and NPCs
     """
     _byte_size: int = 0
-    _nearby: NearbyInfo = None # type: ignore [assignment]
+    _nearby: NearbyInfo
+
+    def __init__(self, *, nearby: NearbyInfo):
+        """
+        Create a new instance of RangeReplyServerPacket.
+
+        Args:
+            nearby (NearbyInfo): 
+        """
+        self._nearby = nearby
 
     @property
     def byte_size(self) -> int:
@@ -32,10 +41,6 @@ class RangeReplyServerPacket(Packet):
     def nearby(self) -> NearbyInfo:
         return self._nearby
 
-    @nearby.setter
-    def nearby(self, nearby: NearbyInfo) -> None:
-        self._nearby = nearby
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -93,13 +98,13 @@ class RangeReplyServerPacket(Packet):
         Returns:
             RangeReplyServerPacket: The data to serialize.
         """
-        data: RangeReplyServerPacket = RangeReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._nearby = NearbyInfo.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            nearby = NearbyInfo.deserialize(reader)
+            result = RangeReplyServerPacket(nearby=nearby)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,9 +15,22 @@ class RecoverAgreeServerPacket(Packet):
     Nearby player gained HP
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _heal_hp: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
+    _player_id: int
+    _heal_hp: int
+    _hp_percentage: int
+
+    def __init__(self, *, player_id: int, heal_hp: int, hp_percentage: int):
+        """
+        Create a new instance of RecoverAgreeServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            heal_hp (int): (Value range is 0-4097152080.)
+            hp_percentage (int): (Value range is 0-252.)
+        """
+        self._player_id = player_id
+        self._heal_hp = heal_hp
+        self._hp_percentage = hp_percentage
 
     @property
     def byte_size(self) -> int:
@@ -31,52 +44,16 @@ class RecoverAgreeServerPacket(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 heal_hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._heal_hp
 
-    @heal_hp.setter
-    def heal_hp(self, heal_hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._heal_hp = heal_hp
-
     @property
     def hp_percentage(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._hp_percentage
 
-    @hp_percentage.setter
-    def hp_percentage(self, hp_percentage: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._hp_percentage = hp_percentage
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -140,15 +117,15 @@ class RecoverAgreeServerPacket(Packet):
         Returns:
             RecoverAgreeServerPacket: The data to serialize.
         """
-        data: RecoverAgreeServerPacket = RecoverAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._heal_hp = reader.get_int()
-            data._hp_percentage = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            heal_hp = reader.get_int()
+            hp_percentage = reader.get_char()
+            result = RecoverAgreeServerPacket(player_id=player_id, heal_hp=heal_hp, hp_percentage=hp_percentage)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,8 +16,19 @@ class RecoverListServerPacket(Packet):
     Stats update
     """
     _byte_size: int = 0
-    _class_id: int = None # type: ignore [assignment]
-    _stats: CharacterStatsUpdate = None # type: ignore [assignment]
+    _class_id: int
+    _stats: CharacterStatsUpdate
+
+    def __init__(self, *, class_id: int, stats: CharacterStatsUpdate):
+        """
+        Create a new instance of RecoverListServerPacket.
+
+        Args:
+            class_id (int): (Value range is 0-64008.)
+            stats (CharacterStatsUpdate): 
+        """
+        self._class_id = class_id
+        self._stats = stats
 
     @property
     def byte_size(self) -> int:
@@ -31,28 +42,12 @@ class RecoverListServerPacket(Packet):
 
     @property
     def class_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._class_id
 
-    @class_id.setter
-    def class_id(self, class_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._class_id = class_id
-
     @property
     def stats(self) -> CharacterStatsUpdate:
         return self._stats
 
-    @stats.setter
-    def stats(self, stats: CharacterStatsUpdate) -> None:
-        self._stats = stats
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -113,14 +108,14 @@ class RecoverListServerPacket(Packet):
         Returns:
             RecoverListServerPacket: The data to serialize.
         """
-        data: RecoverListServerPacket = RecoverListServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._class_id = reader.get_short()
-            data._stats = CharacterStatsUpdate.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            class_id = reader.get_short()
+            stats = CharacterStatsUpdate.deserialize(reader)
+            result = RecoverListServerPacket(class_id=class_id, stats=stats)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,8 +15,19 @@ class RecoverPlayerServerPacket(Packet):
     HP/TP update
     """
     _byte_size: int = 0
-    _hp: int = None # type: ignore [assignment]
-    _tp: int = None # type: ignore [assignment]
+    _hp: int
+    _tp: int
+
+    def __init__(self, *, hp: int, tp: int):
+        """
+        Create a new instance of RecoverPlayerServerPacket.
+
+        Args:
+            hp (int): (Value range is 0-64008.)
+            tp (int): (Value range is 0-64008.)
+        """
+        self._hp = hp
+        self._tp = tp
 
     @property
     def byte_size(self) -> int:
@@ -30,36 +41,12 @@ class RecoverPlayerServerPacket(Packet):
 
     @property
     def hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._hp
 
-    @hp.setter
-    def hp(self, hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._hp = hp
-
     @property
     def tp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._tp
 
-    @tp.setter
-    def tp(self, tp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._tp = tp
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -106,6 +93,7 @@ class RecoverPlayerServerPacket(Packet):
             if data._tp is None:
                 raise SerializationError("tp must be provided.")
             writer.add_short(data._tp)
+            writer.add_short(0)
         finally:
             writer.string_sanitization_mode = old_string_sanitization_mode
 
@@ -120,14 +108,15 @@ class RecoverPlayerServerPacket(Packet):
         Returns:
             RecoverPlayerServerPacket: The data to serialize.
         """
-        data: RecoverPlayerServerPacket = RecoverPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._hp = reader.get_short()
-            data._tp = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            hp = reader.get_short()
+            tp = reader.get_short()
+            reader.get_short()
+            result = RecoverPlayerServerPacket(hp=hp, tp=tp)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -17,11 +17,28 @@ class RecoverReplyServerPacket(Packet):
     Karma/experience update
     """
     _byte_size: int = 0
-    _experience: int = None # type: ignore [assignment]
-    _karma: int = None # type: ignore [assignment]
-    _level_up: Optional[int] = None # type: ignore [assignment]
-    _stat_points: Optional[int] = None # type: ignore [assignment]
-    _skill_points: Optional[int] = None # type: ignore [assignment]
+    _experience: int
+    _karma: int
+    _level_up: Optional[int]
+    _stat_points: Optional[int]
+    _skill_points: Optional[int]
+
+    def __init__(self, *, experience: int, karma: int, level_up: Optional[int] = None, stat_points: Optional[int] = None, skill_points: Optional[int] = None):
+        """
+        Create a new instance of RecoverReplyServerPacket.
+
+        Args:
+            experience (int): (Value range is 0-4097152080.)
+            karma (int): (Value range is 0-64008.)
+            level_up (Optional[int]): A value greater than 0 is "new level" and indicates the player leveled up. The official client reads this if the packet is larger than 6 bytes. (Value range is 0-252.)
+            stat_points (Optional[int]): The official client reads this if the player leveled up (Value range is 0-64008.)
+            skill_points (Optional[int]): The official client reads this if the player leveled up (Value range is 0-64008.)
+        """
+        self._experience = experience
+        self._karma = karma
+        self._level_up = level_up
+        self._stat_points = stat_points
+        self._skill_points = skill_points
 
     @property
     def byte_size(self) -> int:
@@ -35,98 +52,34 @@ class RecoverReplyServerPacket(Packet):
 
     @property
     def experience(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._experience
 
-    @experience.setter
-    def experience(self, experience: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._experience = experience
-
     @property
     def karma(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._karma
 
-    @karma.setter
-    def karma(self, karma: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._karma = karma
-
     @property
     def level_up(self) -> Optional[int]:
         """
         A value greater than 0 is "new level" and indicates the player leveled up.
         The official client reads this if the packet is larger than 6 bytes.
-
-        Note:
-          - Value range is 0-252.
         """
         return self._level_up
 
-    @level_up.setter
-    def level_up(self, level_up: Optional[int]) -> None:
-        """
-        A value greater than 0 is "new level" and indicates the player leveled up.
-        The official client reads this if the packet is larger than 6 bytes.
-
-        Note:
-          - Value range is 0-252.
-        """
-        self._level_up = level_up
-
     @property
     def stat_points(self) -> Optional[int]:
         """
         The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._stat_points
 
-    @stat_points.setter
-    def stat_points(self, stat_points: Optional[int]) -> None:
-        """
-        The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._stat_points = stat_points
-
     @property
     def skill_points(self) -> Optional[int]:
         """
         The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
         """
         return self._skill_points
 
-    @skill_points.setter
-    def skill_points(self, skill_points: Optional[int]) -> None:
-        """
-        The official client reads this if the player leveled up
-
-        Note:
-          - Value range is 0-64008.
-        """
-        self._skill_points = skill_points
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -196,20 +149,23 @@ class RecoverReplyServerPacket(Packet):
         Returns:
             RecoverReplyServerPacket: The data to serialize.
         """
-        data: RecoverReplyServerPacket = RecoverReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._experience = reader.get_int()
-            data._karma = reader.get_short()
+            experience = reader.get_int()
+            karma = reader.get_short()
+            level_up: Optional[int] = None
             if reader.remaining > 0:
-                data._level_up = reader.get_char()
+                level_up = reader.get_char()
+            stat_points: Optional[int] = None
             if reader.remaining > 0:
-                data._stat_points = reader.get_short()
+                stat_points = reader.get_short()
+            skill_points: Optional[int] = None
             if reader.remaining > 0:
-                data._skill_points = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+                skill_points = reader.get_short()
+            result = RecoverReplyServerPacket(experience=experience, karma=karma, level_up=level_up, stat_points=stat_points, skill_points=skill_points)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode