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

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

@@ -14,9 +14,22 @@ class DialogEntry:
     An entry in a quest dialog
     """
     _byte_size: int = 0
-    _entry_type: DialogEntryType = None # type: ignore [assignment]
-    _entry_type_data: 'DialogEntry.EntryTypeData' = None
-    _line: str = None # type: ignore [assignment]
+    _entry_type: DialogEntryType
+    _entry_type_data: 'DialogEntry.EntryTypeData'
+    _line: str
+
+    def __init__(self, *, entry_type: DialogEntryType, entry_type_data: 'DialogEntry.EntryTypeData' = None, line: str):
+        """
+        Create a new instance of DialogEntry.
+
+        Args:
+            entry_type (DialogEntryType): 
+            entry_type_data (DialogEntry.EntryTypeData): Data associated with the `entry_type` field.
+            line (str): 
+        """
+        self._entry_type = entry_type
+        self._entry_type_data = entry_type_data
+        self._line = line
 
     @property
     def byte_size(self) -> int:
@@ -32,29 +45,17 @@ class DialogEntry:
     def entry_type(self) -> DialogEntryType:
         return self._entry_type
 
-    @entry_type.setter
-    def entry_type(self, entry_type: DialogEntryType) -> None:
-        self._entry_type = entry_type
-
     @property
     def entry_type_data(self) -> 'DialogEntry.EntryTypeData':
         """
-        DialogEntry.EntryTypeData: Gets or sets the data associated with the `entry_type` field.
+        DialogEntry.EntryTypeData: Data associated with the `entry_type` field.
         """
         return self._entry_type_data
 
-    @entry_type_data.setter
-    def entry_type_data(self, entry_type_data: 'DialogEntry.EntryTypeData') -> None:
-        self._entry_type_data = entry_type_data
-
     @property
     def line(self) -> str:
         return self._line
 
-    @line.setter
-    def line(self, line: str) -> None:
-        self._line = line
-
     @staticmethod
     def serialize(writer: EoWriter, data: "DialogEntry") -> None:
         """
@@ -64,16 +65,20 @@ class DialogEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (DialogEntry): The data to serialize.
         """
-        if data._entry_type is None:
-            raise SerializationError("entry_type must be provided.")
-        writer.add_short(int(data._entry_type))
-        if data._entry_type == DialogEntryType.Link:
-            if not isinstance(data._entry_type_data, DialogEntry.EntryTypeDataLink):
-                raise SerializationError("Expected entry_type_data to be type DialogEntry.EntryTypeDataLink for entry_type " + DialogEntryType(data._entry_type).name + ".")
-            DialogEntry.EntryTypeDataLink.serialize(writer, data._entry_type_data)
-        if data._line is None:
-            raise SerializationError("line must be provided.")
-        writer.add_string(data._line)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._entry_type is None:
+                raise SerializationError("entry_type must be provided.")
+            writer.add_short(int(data._entry_type))
+            if data._entry_type == DialogEntryType.Link:
+                if not isinstance(data._entry_type_data, DialogEntry.EntryTypeDataLink):
+                    raise SerializationError("Expected entry_type_data to be type DialogEntry.EntryTypeDataLink for entry_type " + DialogEntryType(data._entry_type).name + ".")
+                DialogEntry.EntryTypeDataLink.serialize(writer, data._entry_type_data)
+            if data._line is None:
+                raise SerializationError("line must be provided.")
+            writer.add_string(data._line)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DialogEntry":
@@ -86,16 +91,17 @@ class DialogEntry:
         Returns:
             DialogEntry: The data to serialize.
         """
-        data: DialogEntry = DialogEntry()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._entry_type = DialogEntryType(reader.get_short())
-            if data._entry_type == DialogEntryType.Link:
-                data._entry_type_data = DialogEntry.EntryTypeDataLink.deserialize(reader)
-            data._line = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            entry_type = DialogEntryType(reader.get_short())
+            entry_type_data: DialogEntry.EntryTypeData = None
+            if entry_type == DialogEntryType.Link:
+                entry_type_data = DialogEntry.EntryTypeDataLink.deserialize(reader)
+            line = reader.get_string()
+            result = DialogEntry(entry_type=entry_type, entry_type_data=entry_type_data, line=line)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -103,17 +109,25 @@ class DialogEntry:
         return f"DialogEntry(byte_size={repr(self._byte_size)}, entry_type={repr(self._entry_type)}, entry_type_data={repr(self._entry_type_data)}, line={repr(self._line)})"
 
     EntryTypeData = Union['DialogEntry.EntryTypeDataLink', None]
-    EntryTypeData.__doc__ = \
-        """
-        Data associated with different values of the `entry_type` field.
-        """
+    """
+    Data associated with different values of the `entry_type` field.
+    """
 
     class EntryTypeDataLink:
         """
         Data associated with entry_type value DialogEntryType.Link
         """
         _byte_size: int = 0
-        _link_id: int = None # type: ignore [assignment]
+        _link_id: int
+
+        def __init__(self, *, link_id: int):
+            """
+            Create a new instance of DialogEntry.EntryTypeDataLink.
+
+            Args:
+                link_id (int): (Value range is 0-64008.)
+            """
+            self._link_id = link_id
 
         @property
         def byte_size(self) -> int:
@@ -127,20 +141,8 @@ class DialogEntry:
 
         @property
         def link_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._link_id
 
-        @link_id.setter
-        def link_id(self, link_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._link_id = link_id
-
         @staticmethod
         def serialize(writer: EoWriter, data: "DialogEntry.EntryTypeDataLink") -> None:
             """
@@ -150,9 +152,13 @@ class DialogEntry:
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (DialogEntry.EntryTypeDataLink): The data to serialize.
             """
-            if data._link_id is None:
-                raise SerializationError("link_id must be provided.")
-            writer.add_short(data._link_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._link_id is None:
+                    raise SerializationError("link_id must be provided.")
+                writer.add_short(data._link_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "DialogEntry.EntryTypeDataLink":
@@ -165,13 +171,13 @@ class DialogEntry:
             Returns:
                 DialogEntry.EntryTypeDataLink: The data to serialize.
             """
-            data: DialogEntry.EntryTypeDataLink = DialogEntry.EntryTypeDataLink()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._link_id = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                link_id = reader.get_short()
+                result = DialogEntry.EntryTypeDataLink(link_id=link_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/dialog_quest_entry.py

@@ -12,8 +12,19 @@ class DialogQuestEntry:
     An entry in the quest switcher
     """
     _byte_size: int = 0
-    _quest_id: int = None # type: ignore [assignment]
-    _quest_name: str = None # type: ignore [assignment]
+    _quest_id: int
+    _quest_name: str
+
+    def __init__(self, *, quest_id: int, quest_name: str):
+        """
+        Create a new instance of DialogQuestEntry.
+
+        Args:
+            quest_id (int): (Value range is 0-64008.)
+            quest_name (str): 
+        """
+        self._quest_id = quest_id
+        self._quest_name = quest_name
 
     @property
     def byte_size(self) -> int:
@@ -27,28 +38,12 @@ class DialogQuestEntry:
 
     @property
     def quest_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._quest_id
 
-    @quest_id.setter
-    def quest_id(self, quest_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._quest_id = quest_id
-
     @property
     def quest_name(self) -> str:
         return self._quest_name
 
-    @quest_name.setter
-    def quest_name(self, quest_name: str) -> None:
-        self._quest_name = quest_name
-
     @staticmethod
     def serialize(writer: EoWriter, data: "DialogQuestEntry") -> None:
         """
@@ -58,12 +53,16 @@ class DialogQuestEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (DialogQuestEntry): The data to serialize.
         """
-        if data._quest_id is None:
-            raise SerializationError("quest_id must be provided.")
-        writer.add_short(data._quest_id)
-        if data._quest_name is None:
-            raise SerializationError("quest_name must be provided.")
-        writer.add_string(data._quest_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._quest_id is None:
+                raise SerializationError("quest_id must be provided.")
+            writer.add_short(data._quest_id)
+            if data._quest_name is None:
+                raise SerializationError("quest_name must be provided.")
+            writer.add_string(data._quest_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DialogQuestEntry":
@@ -76,14 +75,14 @@ class DialogQuestEntry:
         Returns:
             DialogQuestEntry: The data to serialize.
         """
-        data: DialogQuestEntry = DialogQuestEntry()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._quest_id = reader.get_short()
-            data._quest_name = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            quest_id = reader.get_short()
+            quest_name = reader.get_string()
+            result = DialogQuestEntry(quest_id=quest_id, quest_name=quest_name)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

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

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

@@ -16,7 +16,16 @@ class DoorOpenServerPacket(Packet):
     Nearby door opening
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
+    _coords: Coords
+
+    def __init__(self, *, coords: Coords):
+        """
+        Create a new instance of DoorOpenServerPacket.
+
+        Args:
+            coords (Coords): The official server erroneously encodes the Y coordinate as a short. The official client reads each coordinate as a char.
+        """
+        self._coords = coords
 
     @property
     def byte_size(self) -> int:
@@ -30,12 +39,12 @@ class DoorOpenServerPacket(Packet):
 
     @property
     def coords(self) -> Coords:
+        """
+        The official server erroneously encodes the Y coordinate as a short.
+        The official client reads each coordinate as a char.
+        """
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -74,10 +83,13 @@ class DoorOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (DoorOpenServerPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        writer.add_char(0)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DoorOpenServerPacket":
@@ -90,14 +102,13 @@ class DoorOpenServerPacket(Packet):
         Returns:
             DoorOpenServerPacket: The data to serialize.
         """
-        data: DoorOpenServerPacket = DoorOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            result = DoorOpenServerPacket(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/effect_admin_server_packet.py

@@ -15,10 +15,25 @@ class EffectAdminServerPacket(Packet):
     Nearby character taking spike damage
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
-    _died: bool = None # type: ignore [assignment]
-    _damage: int = None # type: ignore [assignment]
+    _player_id: int
+    _hp_percentage: int
+    _died: bool
+    _damage: int
+
+    def __init__(self, *, player_id: int, hp_percentage: int, died: bool, damage: int):
+        """
+        Create a new instance of EffectAdminServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            hp_percentage (int): (Value range is 0-252.)
+            died (bool): 
+            damage (int): (Value range is 0-16194276.)
+        """
+        self._player_id = player_id
+        self._hp_percentage = hp_percentage
+        self._died = died
+        self._damage = damage
 
     @property
     def byte_size(self) -> int:
@@ -32,60 +47,20 @@ class EffectAdminServerPacket(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 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
-
     @property
     def died(self) -> bool:
         return self._died
 
-    @died.setter
-    def died(self, died: bool) -> None:
-        self._died = died
-
     @property
     def damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._damage
 
-    @damage.setter
-    def damage(self, damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._damage = damage
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -124,18 +99,22 @@ class EffectAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectAdminServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._died is None:
-            raise SerializationError("died must be provided.")
-        writer.add_char(1 if data._died else 0)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._died is None:
+                raise SerializationError("died must be provided.")
+            writer.add_char(1 if data._died else 0)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectAdminServerPacket":
@@ -148,16 +127,16 @@ class EffectAdminServerPacket(Packet):
         Returns:
             EffectAdminServerPacket: The data to serialize.
         """
-        data: EffectAdminServerPacket = EffectAdminServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._hp_percentage = reader.get_char()
-            data._died = reader.get_char() != 0
-            data._damage = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            hp_percentage = reader.get_char()
+            died = reader.get_char() != 0
+            damage = reader.get_three()
+            result = EffectAdminServerPacket(player_id=player_id, hp_percentage=hp_percentage, died=died, damage=damage)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode