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

eolib/protocol/_generated/net/server/board_open_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 .board_post_listing import BoardPostListing
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,9 +18,21 @@ class BoardOpenServerPacket(Packet):
     Reply to opening a town board
     """
     _byte_size: int = 0
-    _board_id: int = None # type: ignore [assignment]
-    _posts_count: int = None # type: ignore [assignment]
-    _posts: list[BoardPostListing] = None # type: ignore [assignment]
+    _board_id: int
+    _posts_count: int
+    _posts: tuple[BoardPostListing, ...]
+
+    def __init__(self, *, board_id: int, posts: Iterable[BoardPostListing]):
+        """
+        Create a new instance of BoardOpenServerPacket.
+
+        Args:
+            board_id (int): (Value range is 0-252.)
+            posts (Iterable[BoardPostListing]): (Length must be 252 or less.)
+        """
+        self._board_id = board_id
+        self._posts = tuple(posts)
+        self._posts_count = len(self._posts)
 
     @property
     def byte_size(self) -> int:
@@ -33,37 +46,12 @@ class BoardOpenServerPacket(Packet):
 
     @property
     def board_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._board_id
 
-    @board_id.setter
-    def board_id(self, board_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._board_id = board_id
-
     @property
-    def posts(self) -> list[BoardPostListing]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def posts(self) -> tuple[BoardPostListing, ...]:
         return self._posts
 
-    @posts.setter
-    def posts(self, posts: list[BoardPostListing]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._posts = posts
-        self._posts_count = len(self._posts)
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -133,20 +121,20 @@ class BoardOpenServerPacket(Packet):
         Returns:
             BoardOpenServerPacket: The data to serialize.
         """
-        data: BoardOpenServerPacket = BoardOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._board_id = reader.get_char()
-            data._posts_count = reader.get_char()
-            data._posts = []
-            for i in range(data._posts_count):
-                data._posts.append(BoardPostListing.deserialize(reader))
+            board_id = reader.get_char()
+            posts_count = reader.get_char()
+            posts = []
+            for i in range(posts_count):
+                posts.append(BoardPostListing.deserialize(reader))
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BoardOpenServerPacket(board_id=board_id, posts=posts)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,8 +15,19 @@ class BoardPlayerServerPacket(Packet):
     Reply to reading a post on a town board
     """
     _byte_size: int = 0
-    _post_id: int = None # type: ignore [assignment]
-    _post_body: str = None # type: ignore [assignment]
+    _post_id: int
+    _post_body: str
+
+    def __init__(self, *, post_id: int, post_body: str):
+        """
+        Create a new instance of BoardPlayerServerPacket.
+
+        Args:
+            post_id (int): (Value range is 0-64008.)
+            post_body (str): 
+        """
+        self._post_id = post_id
+        self._post_body = post_body
 
     @property
     def byte_size(self) -> int:
@@ -30,28 +41,12 @@ class BoardPlayerServerPacket(Packet):
 
     @property
     def post_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._post_id
 
-    @post_id.setter
-    def post_id(self, post_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._post_id = post_id
-
     @property
     def post_body(self) -> str:
         return self._post_body
 
-    @post_body.setter
-    def post_body(self, post_body: str) -> None:
-        self._post_body = post_body
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -114,16 +109,16 @@ class BoardPlayerServerPacket(Packet):
         Returns:
             BoardPlayerServerPacket: The data to serialize.
         """
-        data: BoardPlayerServerPacket = BoardPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._post_id = reader.get_short()
-            data._post_body = reader.get_string()
+            post_id = reader.get_short()
+            post_body = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BoardPlayerServerPacket(post_id=post_id, post_body=post_body)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,9 +12,22 @@ class BoardPostListing:
     An entry in the list of town board posts
     """
     _byte_size: int = 0
-    _post_id: int = None # type: ignore [assignment]
-    _author: str = None # type: ignore [assignment]
-    _subject: str = None # type: ignore [assignment]
+    _post_id: int
+    _author: str
+    _subject: str
+
+    def __init__(self, *, post_id: int, author: str, subject: str):
+        """
+        Create a new instance of BoardPostListing.
+
+        Args:
+            post_id (int): (Value range is 0-64008.)
+            author (str): 
+            subject (str): 
+        """
+        self._post_id = post_id
+        self._author = author
+        self._subject = subject
 
     @property
     def byte_size(self) -> int:
@@ -28,36 +41,16 @@ class BoardPostListing:
 
     @property
     def post_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._post_id
 
-    @post_id.setter
-    def post_id(self, post_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._post_id = post_id
-
     @property
     def author(self) -> str:
         return self._author
 
-    @author.setter
-    def author(self, author: str) -> None:
-        self._author = author
-
     @property
     def subject(self) -> str:
         return self._subject
 
-    @subject.setter
-    def subject(self, subject: str) -> None:
-        self._subject = subject
-
     @staticmethod
     def serialize(writer: EoWriter, data: "BoardPostListing") -> None:
         """
@@ -96,19 +89,19 @@ class BoardPostListing:
         Returns:
             BoardPostListing: The data to serialize.
         """
-        data: BoardPostListing = BoardPostListing()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._post_id = reader.get_short()
+            post_id = reader.get_short()
             reader.next_chunk()
-            data._author = reader.get_string()
+            author = reader.get_string()
             reader.next_chunk()
-            data._subject = reader.get_string()
+            subject = reader.get_string()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BoardPostListing(post_id=post_id, author=author, subject=subject)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/book_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 .character_icon import CharacterIcon
 from .character_details import CharacterDetails
 from ..packet_family import PacketFamily
@@ -18,9 +19,22 @@ class BookReplyServerPacket(Packet):
     Reply to requesting a book
     """
     _byte_size: int = 0
-    _details: CharacterDetails = None # type: ignore [assignment]
-    _icon: CharacterIcon = None # type: ignore [assignment]
-    _quest_names: list[str] = None # type: ignore [assignment]
+    _details: CharacterDetails
+    _icon: CharacterIcon
+    _quest_names: tuple[str, ...]
+
+    def __init__(self, *, details: CharacterDetails, icon: CharacterIcon, quest_names: Iterable[str]):
+        """
+        Create a new instance of BookReplyServerPacket.
+
+        Args:
+            details (CharacterDetails): 
+            icon (CharacterIcon): 
+            quest_names (Iterable[str]): 
+        """
+        self._details = details
+        self._icon = icon
+        self._quest_names = tuple(quest_names)
 
     @property
     def byte_size(self) -> int:
@@ -36,26 +50,14 @@ class BookReplyServerPacket(Packet):
     def details(self) -> CharacterDetails:
         return self._details
 
-    @details.setter
-    def details(self, details: CharacterDetails) -> None:
-        self._details = details
-
     @property
     def icon(self) -> CharacterIcon:
         return self._icon
 
-    @icon.setter
-    def icon(self, icon: CharacterIcon) -> None:
-        self._icon = icon
-
     @property
-    def quest_names(self) -> list[str]:
+    def quest_names(self) -> tuple[str, ...]:
         return self._quest_names
 
-    @quest_names.setter
-    def quest_names(self, quest_names: list[str]) -> None:
-        self._quest_names = quest_names
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -124,21 +126,21 @@ class BookReplyServerPacket(Packet):
         Returns:
             BookReplyServerPacket: The data to serialize.
         """
-        data: BookReplyServerPacket = BookReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
             reader.chunked_reading_mode = True
-            data._details = CharacterDetails.deserialize(reader)
-            data._icon = CharacterIcon(reader.get_char())
+            details = CharacterDetails.deserialize(reader)
+            icon = CharacterIcon(reader.get_char())
             reader.next_chunk()
-            data._quest_names = []
+            quest_names = []
             while reader.remaining > 0:
-                data._quest_names.append(reader.get_string())
+                quest_names.append(reader.get_string())
                 reader.next_chunk()
             reader.chunked_reading_mode = False
-            data._byte_size = reader.position - reader_start_position
-            return data
+            result = BookReplyServerPacket(details=details, icon=icon, quest_names=quest_names)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -3,6 +3,8 @@
 # This file should not be modified.
 # Changes will be lost when code is regenerated.
 
+from typing import cast
+from typing import Optional
 from .npc_killed_data import NpcKilledData
 from .level_up_stats import LevelUpStats
 from ..packet_family import PacketFamily
@@ -14,14 +16,31 @@ from .....data.eo_reader import EoReader
 
 class CastAcceptServerPacket(Packet):
     """
-    Nearby NPC killed by player spell and you leveled up
+    Nearby NPC killed by player spell and killer leveled up
     """
     _byte_size: int = 0
-    _spell_id: int = None # type: ignore [assignment]
-    _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
-    _caster_tp: int = None # type: ignore [assignment]
-    _experience: int = None # type: ignore [assignment]
-    _level_up: LevelUpStats = None # type: ignore [assignment]
+    _spell_id: int
+    _npc_killed_data: NpcKilledData
+    _caster_tp: Optional[int]
+    _experience: Optional[int]
+    _level_up: Optional[LevelUpStats]
+
+    def __init__(self, *, spell_id: int, npc_killed_data: NpcKilledData, caster_tp: Optional[int] = None, experience: Optional[int] = None, level_up: Optional[LevelUpStats] = None):
+        """
+        Create a new instance of CastAcceptServerPacket.
+
+        Args:
+            spell_id (int): (Value range is 0-64008.)
+            npc_killed_data (NpcKilledData): 
+            caster_tp (Optional[int]): This field should be sent to the killer, but not nearby players (Value range is 0-64008.)
+            experience (Optional[int]): This field should be sent to the killer, but not nearby players (Value range is 0-4097152080.)
+            level_up (Optional[LevelUpStats]): This field should be sent to the killer if they leveled up, but not nearby players
+        """
+        self._spell_id = spell_id
+        self._npc_killed_data = npc_killed_data
+        self._caster_tp = caster_tp
+        self._experience = experience
+        self._level_up = level_up
 
     @property
     def byte_size(self) -> int:
@@ -35,68 +54,33 @@ class CastAcceptServerPacket(Packet):
 
     @property
     def spell_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._spell_id
 
-    @spell_id.setter
-    def spell_id(self, spell_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._spell_id = spell_id
-
     @property
     def npc_killed_data(self) -> NpcKilledData:
         return self._npc_killed_data
 
-    @npc_killed_data.setter
-    def npc_killed_data(self, npc_killed_data: NpcKilledData) -> None:
-        self._npc_killed_data = npc_killed_data
-
     @property
-    def caster_tp(self) -> int:
+    def caster_tp(self) -> Optional[int]:
         """
-        Note:
-          - Value range is 0-64008.
+        This field should be sent to the killer, but not nearby players
         """
         return self._caster_tp
 
-    @caster_tp.setter
-    def caster_tp(self, caster_tp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._caster_tp = caster_tp
-
     @property
-    def experience(self) -> int:
+    def experience(self) -> Optional[int]:
         """
-        Note:
-          - Value range is 0-4097152080.
+        This field should be sent to the killer, but not nearby players
         """
         return self._experience
 
-    @experience.setter
-    def experience(self, experience: int) -> None:
+    @property
+    def level_up(self) -> Optional[LevelUpStats]:
         """
-        Note:
-          - Value range is 0-4097152080.
+        This field should be sent to the killer if they leveled up, but not nearby players
         """
-        self._experience = experience
-
-    @property
-    def level_up(self) -> LevelUpStats:
         return self._level_up
 
-    @level_up.setter
-    def level_up(self, level_up: LevelUpStats) -> None:
-        self._level_up = level_up
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -143,15 +127,15 @@ class CastAcceptServerPacket(Packet):
             if data._npc_killed_data is None:
                 raise SerializationError("npc_killed_data must be provided.")
             NpcKilledData.serialize(writer, data._npc_killed_data)
-            if data._caster_tp is None:
-                raise SerializationError("caster_tp must be provided.")
-            writer.add_short(data._caster_tp)
-            if data._experience is None:
-                raise SerializationError("experience must be provided.")
-            writer.add_int(data._experience)
-            if data._level_up is None:
-                raise SerializationError("level_up must be provided.")
-            LevelUpStats.serialize(writer, data._level_up)
+            reached_missing_optional = data._caster_tp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._caster_tp))
+            reached_missing_optional = reached_missing_optional or data._experience is None
+            if not reached_missing_optional:
+                writer.add_int(cast(int, data._experience))
+            reached_missing_optional = reached_missing_optional or data._level_up is None
+            if not reached_missing_optional:
+                LevelUpStats.serialize(writer, cast(LevelUpStats, data._level_up))
         finally:
             writer.string_sanitization_mode = old_string_sanitization_mode
 
@@ -166,17 +150,23 @@ class CastAcceptServerPacket(Packet):
         Returns:
             CastAcceptServerPacket: The data to serialize.
         """
-        data: CastAcceptServerPacket = CastAcceptServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._spell_id = reader.get_short()
-            data._npc_killed_data = NpcKilledData.deserialize(reader)
-            data._caster_tp = reader.get_short()
-            data._experience = reader.get_int()
-            data._level_up = LevelUpStats.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            spell_id = reader.get_short()
+            npc_killed_data = NpcKilledData.deserialize(reader)
+            caster_tp: Optional[int] = None
+            if reader.remaining > 0:
+                caster_tp = reader.get_short()
+            experience: Optional[int] = None
+            if reader.remaining > 0:
+                experience = reader.get_int()
+            level_up: Optional[LevelUpStats] = None
+            if reader.remaining > 0:
+                level_up = LevelUpStats.deserialize(reader)
+            result = CastAcceptServerPacket(spell_id=spell_id, npc_killed_data=npc_killed_data, caster_tp=caster_tp, experience=experience, level_up=level_up)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode