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

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

@@ -15,6 +15,11 @@ class MessagePongServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of MessagePongServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -63,9 +68,11 @@ class MessagePongServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessagePongServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_short(2)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessagePongServerPacket":
@@ -78,14 +85,13 @@ class MessagePongServerPacket(Packet):
         Returns:
             MessagePongServerPacket: The data to serialize.
         """
-        data: MessagePongServerPacket = MessagePongServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reader.get_short()
+            result = MessagePongServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class MusicPlayerServerPacket(Packet):
     Sound effect
     """
     _byte_size: int = 0
-    _sound_id: int = None # type: ignore [assignment]
+    _sound_id: int
+
+    def __init__(self, *, sound_id: int):
+        """
+        Create a new instance of MusicPlayerServerPacket.
+
+        Args:
+            sound_id (int): (Value range is 0-252.)
+        """
+        self._sound_id = sound_id
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class MusicPlayerServerPacket(Packet):
 
     @property
     def sound_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._sound_id
 
-    @sound_id.setter
-    def sound_id(self, sound_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._sound_id = sound_id
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -81,9 +78,13 @@ class MusicPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MusicPlayerServerPacket): The data to serialize.
         """
-        if data._sound_id is None:
-            raise SerializationError("sound_id must be provided.")
-        writer.add_char(data._sound_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sound_id is None:
+                raise SerializationError("sound_id must be provided.")
+            writer.add_char(data._sound_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MusicPlayerServerPacket":
@@ -96,13 +97,13 @@ class MusicPlayerServerPacket(Packet):
         Returns:
             MusicPlayerServerPacket: The data to serialize.
         """
-        data: MusicPlayerServerPacket = MusicPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._sound_id = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            sound_id = reader.get_char()
+            result = MusicPlayerServerPacket(sound_id=sound_id)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .npc_map_info import NpcMapInfo
 from .item_map_info import ItemMapInfo
 from .character_map_info import CharacterMapInfo
@@ -16,10 +17,24 @@ class NearbyInfo:
     Information about nearby entities
     """
     _byte_size: int = 0
-    _characters_count: int = None # type: ignore [assignment]
-    _characters: list[CharacterMapInfo] = None # type: ignore [assignment]
-    _npcs: list[NpcMapInfo] = None # type: ignore [assignment]
-    _items: list[ItemMapInfo] = None # type: ignore [assignment]
+    _characters_count: int
+    _characters: tuple[CharacterMapInfo, ...]
+    _npcs: tuple[NpcMapInfo, ...]
+    _items: tuple[ItemMapInfo, ...]
+
+    def __init__(self, *, characters: Iterable[CharacterMapInfo], npcs: Iterable[NpcMapInfo], items: Iterable[ItemMapInfo]):
+        """
+        Create a new instance of NearbyInfo.
+
+        Args:
+            characters (Iterable[CharacterMapInfo]): (Length must be 252 or less.)
+            npcs (Iterable[NpcMapInfo]): 
+            items (Iterable[ItemMapInfo]): 
+        """
+        self._characters = tuple(characters)
+        self._characters_count = len(self._characters)
+        self._npcs = tuple(npcs)
+        self._items = tuple(items)
 
     @property
     def byte_size(self) -> int:
@@ -32,38 +47,17 @@ class NearbyInfo:
         return self._byte_size
 
     @property
-    def characters(self) -> list[CharacterMapInfo]:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
+    def characters(self) -> tuple[CharacterMapInfo, ...]:
         return self._characters
 
-    @characters.setter
-    def characters(self, characters: list[CharacterMapInfo]) -> None:
-        """
-        Note:
-          - Length must be 252 or less.
-        """
-        self._characters = characters
-        self._characters_count = len(self._characters)
-
     @property
-    def npcs(self) -> list[NpcMapInfo]:
+    def npcs(self) -> tuple[NpcMapInfo, ...]:
         return self._npcs
 
-    @npcs.setter
-    def npcs(self, npcs: list[NpcMapInfo]) -> None:
-        self._npcs = npcs
-
     @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 serialize(writer: EoWriter, data: "NearbyInfo") -> None:
         """
@@ -73,27 +67,32 @@ class NearbyInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NearbyInfo): The data to serialize.
         """
-        if data._characters_count is None:
-            raise SerializationError("characters_count must be provided.")
-        writer.add_char(data._characters_count)
-        writer.add_byte(0xFF)
-        if data._characters is None:
-            raise SerializationError("characters must be provided.")
-        if len(data._characters) > 252:
-            raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
-        for i in range(data._characters_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._characters_count is None:
+                raise SerializationError("characters_count must be provided.")
+            writer.add_char(data._characters_count)
+            writer.string_sanitization_mode = True
+            writer.add_byte(0xFF)
+            if data._characters is None:
+                raise SerializationError("characters must be provided.")
+            if len(data._characters) > 252:
+                raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
+            for i in range(data._characters_count):
+                CharacterMapInfo.serialize(writer, data._characters[i])
                 writer.add_byte(0xFF)
-            CharacterMapInfo.serialize(writer, data._characters[i])
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        for i in range(len(data._npcs)):
-            NpcMapInfo.serialize(writer, data._npcs[i])
-        writer.add_byte(0xFF)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ItemMapInfo.serialize(writer, data._items[i])
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            for i in range(len(data._npcs)):
+                NpcMapInfo.serialize(writer, data._npcs[i])
+            writer.add_byte(0xFF)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ItemMapInfo.serialize(writer, data._items[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NearbyInfo":
@@ -106,30 +105,29 @@ class NearbyInfo:
         Returns:
             NearbyInfo: The data to serialize.
         """
-        data: NearbyInfo = NearbyInfo()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._characters_count = reader.get_char()
+            characters_count = reader.get_char()
             reader.chunked_reading_mode = True
             reader.next_chunk()
-            data._characters = []
-            for i in range(data._characters_count):
-                data._characters.append(CharacterMapInfo.deserialize(reader))
-                if i + 1 < data._characters_count:
-                    reader.next_chunk()
+            characters = []
+            for i in range(characters_count):
+                characters.append(CharacterMapInfo.deserialize(reader))
+                reader.next_chunk()
             npcs_length = int(reader.remaining / 6)
-            data._npcs = []
+            npcs = []
             for i in range(npcs_length):
-                data._npcs.append(NpcMapInfo.deserialize(reader))
+                npcs.append(NpcMapInfo.deserialize(reader))
             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 = NearbyInfo(characters=characters, npcs=npcs, 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/npc_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,12 +16,25 @@ from .....data.eo_reader import EoReader
 
 class NpcAcceptServerPacket(Packet):
     """
-    Nearby NPC killed by player and you leveled up
+    Nearby NPC killed and killer leveled up
     """
     _byte_size: int = 0
-    _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
-    _experience: int = None # type: ignore [assignment]
-    _level_up: LevelUpStats = None # type: ignore [assignment]
+    _npc_killed_data: NpcKilledData
+    _experience: Optional[int]
+    _level_up: Optional[LevelUpStats]
+
+    def __init__(self, *, npc_killed_data: NpcKilledData, experience: Optional[int] = None, level_up: Optional[LevelUpStats] = None):
+        """
+        Create a new instance of NpcAcceptServerPacket.
+
+        Args:
+            npc_killed_data (NpcKilledData): 
+            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._npc_killed_data = npc_killed_data
+        self._experience = experience
+        self._level_up = level_up
 
     @property
     def byte_size(self) -> int:
@@ -35,34 +50,20 @@ class NpcAcceptServerPacket(Packet):
     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 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:
         """
@@ -101,15 +102,19 @@ class NpcAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcAcceptServerPacket): The data to serialize.
         """
-        if data._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        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)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            reached_missing_optional = 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
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcAcceptServerPacket":
@@ -122,15 +127,19 @@ class NpcAcceptServerPacket(Packet):
         Returns:
             NpcAcceptServerPacket: The data to serialize.
         """
-        data: NpcAcceptServerPacket = NpcAcceptServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._npc_killed_data = NpcKilledData.deserialize(reader)
-            data._experience = reader.get_int()
-            data._level_up = LevelUpStats.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            npc_killed_data = NpcKilledData.deserialize(reader)
+            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 = NpcAcceptServerPacket(npc_killed_data=npc_killed_data, 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
 

eolib/protocol/_generated/net/server/npc_agree_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 .npc_map_info import NpcMapInfo
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
@@ -17,8 +18,18 @@ class NpcAgreeServerPacket(Packet):
     Reply to request for information about nearby NPCs
     """
     _byte_size: int = 0
-    _npcs_count: int = None # type: ignore [assignment]
-    _npcs: list[NpcMapInfo] = None # type: ignore [assignment]
+    _npcs_count: int
+    _npcs: tuple[NpcMapInfo, ...]
+
+    def __init__(self, *, npcs: Iterable[NpcMapInfo]):
+        """
+        Create a new instance of NpcAgreeServerPacket.
+
+        Args:
+            npcs (Iterable[NpcMapInfo]): (Length must be 252 or less.)
+        """
+        self._npcs = tuple(npcs)
+        self._npcs_count = len(self._npcs)
 
     @property
     def byte_size(self) -> int:
@@ -31,22 +42,9 @@ class NpcAgreeServerPacket(Packet):
         return self._byte_size
 
     @property
-    def npcs(self) -> list[NpcMapInfo]:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
+    def npcs(self) -> tuple[NpcMapInfo, ...]:
         return self._npcs
 
-    @npcs.setter
-    def npcs(self, npcs: list[NpcMapInfo]) -> None:
-        """
-        Note:
-          - Length must be 64008 or less.
-        """
-        self._npcs = npcs
-        self._npcs_count = len(self._npcs)
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -85,15 +83,19 @@ class NpcAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcAgreeServerPacket): The data to serialize.
         """
-        if data._npcs_count is None:
-            raise SerializationError("npcs_count must be provided.")
-        writer.add_short(data._npcs_count)
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        if len(data._npcs) > 64008:
-            raise SerializationError(f"Expected length of npcs to be 64008 or less, got {len(data._npcs)}.")
-        for i in range(data._npcs_count):
-            NpcMapInfo.serialize(writer, data._npcs[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npcs_count is None:
+                raise SerializationError("npcs_count must be provided.")
+            writer.add_char(data._npcs_count)
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            if len(data._npcs) > 252:
+                raise SerializationError(f"Expected length of npcs to be 252 or less, got {len(data._npcs)}.")
+            for i in range(data._npcs_count):
+                NpcMapInfo.serialize(writer, data._npcs[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcAgreeServerPacket":
@@ -106,16 +108,16 @@ class NpcAgreeServerPacket(Packet):
         Returns:
             NpcAgreeServerPacket: The data to serialize.
         """
-        data: NpcAgreeServerPacket = NpcAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._npcs_count = reader.get_short()
-            data._npcs = []
-            for i in range(data._npcs_count):
-                data._npcs.append(NpcMapInfo.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+            npcs_count = reader.get_char()
+            npcs = []
+            for i in range(npcs_count):
+                npcs.append(NpcMapInfo.deserialize(reader))
+            result = NpcAgreeServerPacket(npcs=npcs)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,8 +15,19 @@ class NpcDialogServerPacket(Packet):
     NPC chat message
     """
     _byte_size: int = 0
-    _npc_index: int = None # type: ignore [assignment]
-    _message: str = None # type: ignore [assignment]
+    _npc_index: int
+    _message: str
+
+    def __init__(self, *, npc_index: int, message: str):
+        """
+        Create a new instance of NpcDialogServerPacket.
+
+        Args:
+            npc_index (int): (Value range is 0-64008.)
+            message (str): 
+        """
+        self._npc_index = npc_index
+        self._message = message
 
     @property
     def byte_size(self) -> int:
@@ -30,28 +41,12 @@ class NpcDialogServerPacket(Packet):
 
     @property
     def npc_index(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._npc_index
 
-    @npc_index.setter
-    def npc_index(self, npc_index: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._npc_index = npc_index
-
     @property
     def message(self) -> str:
         return self._message
 
-    @message.setter
-    def message(self, message: str) -> None:
-        self._message = message
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -90,12 +85,16 @@ class NpcDialogServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcDialogServerPacket): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcDialogServerPacket":
@@ -108,14 +107,14 @@ class NpcDialogServerPacket(Packet):
         Returns:
             NpcDialogServerPacket: The data to serialize.
         """
-        data: NpcDialogServerPacket = NpcDialogServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._npc_index = reader.get_short()
-            data._message = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            npc_index = reader.get_short()
+            message = reader.get_string()
+            result = NpcDialogServerPacket(npc_index=npc_index, message=message)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode