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

eolib/protocol/_generated/net/client/chair_request_client_packet.py

@@ -88,13 +88,17 @@ class ChairRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChairRequestClientPacket): The data to serialize.
         """
-        if data._sit_action is None:
-            raise SerializationError("sit_action must be provided.")
-        writer.add_char(int(data._sit_action))
-        if data._sit_action == SitAction.Sit:
-            if not isinstance(data._sit_action_data, ChairRequestClientPacket.SitActionDataSit):
-                raise SerializationError("Expected sit_action_data to be type ChairRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
-            ChairRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sit_action is None:
+                raise SerializationError("sit_action must be provided.")
+            writer.add_char(int(data._sit_action))
+            if data._sit_action == SitAction.Sit:
+                if not isinstance(data._sit_action_data, ChairRequestClientPacket.SitActionDataSit):
+                    raise SerializationError("Expected sit_action_data to be type ChairRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
+                ChairRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChairRequestClientPacket":
@@ -123,10 +127,9 @@ class ChairRequestClientPacket(Packet):
         return f"ChairRequestClientPacket(byte_size={repr(self._byte_size)}, sit_action={repr(self._sit_action)}, sit_action_data={repr(self._sit_action_data)})"
 
     SitActionData = Union['ChairRequestClientPacket.SitActionDataSit', None]
-    SitActionData.__doc__ = \
-        """
-        Data associated with different values of the `sit_action` field.
-        """
+    """
+    Data associated with different values of the `sit_action` field.
+    """
 
     class SitActionDataSit:
         """
@@ -162,9 +165,13 @@ class ChairRequestClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ChairRequestClientPacket.SitActionDataSit): The data to serialize.
             """
-            if data._coords is None:
-                raise SerializationError("coords must be provided.")
-            Coords.serialize(writer, data._coords)
+            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) -> "ChairRequestClientPacket.SitActionDataSit":

eolib/protocol/_generated/net/client/character_create_client_packet.py

@@ -151,26 +151,32 @@ class CharacterCreateClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterCreateClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._gender is None:
-            raise SerializationError("gender must be provided.")
-        writer.add_short(int(data._gender))
-        if data._hair_style is None:
-            raise SerializationError("hair_style must be provided.")
-        writer.add_short(data._hair_style)
-        if data._hair_color is None:
-            raise SerializationError("hair_color must be provided.")
-        writer.add_short(data._hair_color)
-        if data._skin is None:
-            raise SerializationError("skin must be provided.")
-        writer.add_short(data._skin)
-        writer.add_byte(0xFF)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._gender is None:
+                raise SerializationError("gender must be provided.")
+            writer.add_short(int(data._gender))
+            if data._hair_style is None:
+                raise SerializationError("hair_style must be provided.")
+            writer.add_short(data._hair_style)
+            if data._hair_color is None:
+                raise SerializationError("hair_color must be provided.")
+            writer.add_short(data._hair_color)
+            if data._skin is None:
+                raise SerializationError("skin must be provided.")
+            writer.add_short(data._skin)
+            writer.add_byte(0xFF)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterCreateClientPacket":

eolib/protocol/_generated/net/client/character_remove_client_packet.py

@@ -98,12 +98,16 @@ class CharacterRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterRemoveClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._character_id is None:
-            raise SerializationError("character_id must be provided.")
-        writer.add_int(data._character_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._character_id is None:
+                raise SerializationError("character_id must be provided.")
+            writer.add_int(data._character_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterRemoveClientPacket":

eolib/protocol/_generated/net/client/character_request_client_packet.py

@@ -68,8 +68,14 @@ class CharacterRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterRequestClientPacket): The data to serialize.
         """
-        writer.add_string(data._request_string)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            writer.add_string(data._request_string)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterRequestClientPacket":

eolib/protocol/_generated/net/client/character_take_client_packet.py

@@ -81,9 +81,13 @@ class CharacterTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharacterTakeClientPacket): The data to serialize.
         """
-        if data._character_id is None:
-            raise SerializationError("character_id must be provided.")
-        writer.add_int(data._character_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._character_id is None:
+                raise SerializationError("character_id must be provided.")
+            writer.add_int(data._character_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharacterTakeClientPacket":

eolib/protocol/_generated/net/client/chest_add_client_packet.py

@@ -84,12 +84,16 @@ class ChestAddClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestAddClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._add_item is None:
-            raise SerializationError("add_item must be provided.")
-        ThreeItem.serialize(writer, data._add_item)
+        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)
+            if data._add_item is None:
+                raise SerializationError("add_item must be provided.")
+            ThreeItem.serialize(writer, data._add_item)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestAddClientPacket":

eolib/protocol/_generated/net/client/chest_open_client_packet.py

@@ -74,9 +74,13 @@ class ChestOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestOpenClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        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) -> "ChestOpenClientPacket":

eolib/protocol/_generated/net/client/chest_take_client_packet.py

@@ -91,12 +91,16 @@ class ChestTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChestTakeClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._take_item_id is None:
-            raise SerializationError("take_item_id must be provided.")
-        writer.add_short(data._take_item_id)
+        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)
+            if data._take_item_id is None:
+                raise SerializationError("take_item_id must be provided.")
+            writer.add_short(data._take_item_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ChestTakeClientPacket":

eolib/protocol/_generated/net/client/citizen_accept_client_packet.py

@@ -98,12 +98,16 @@ class CitizenAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenAcceptClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenAcceptClientPacket":

eolib/protocol/_generated/net/client/citizen_open_client_packet.py

@@ -81,9 +81,13 @@ class CitizenOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenOpenClientPacket): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenOpenClientPacket":

eolib/protocol/_generated/net/client/citizen_remove_client_packet.py

@@ -81,9 +81,13 @@ class CitizenRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenRemoveClientPacket): The data to serialize.
         """
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenRemoveClientPacket":

eolib/protocol/_generated/net/client/citizen_reply_client_packet.py

@@ -116,22 +116,28 @@ class CitizenReplyClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenReplyClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        writer.add_byte(0xFF)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
-        writer.add_byte(0xFF)
-        if data._answers is None:
-            raise SerializationError("answers must be provided.")
-        if len(data._answers) != 3:
-            raise SerializationError(f"Expected length of answers to be exactly 3, got {len(data._answers)}.")
-        for i in range(3):
-            if i > 0:
-                writer.add_byte(0xFF)
-            writer.add_string(data._answers[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            writer.add_byte(0xFF)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+            writer.add_byte(0xFF)
+            if data._answers is None:
+                raise SerializationError("answers must be provided.")
+            if len(data._answers) != 3:
+                raise SerializationError(f"Expected length of answers to be exactly 3, got {len(data._answers)}.")
+            for i in range(3):
+                if i > 0:
+                    writer.add_byte(0xFF)
+                writer.add_string(data._answers[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenReplyClientPacket":

eolib/protocol/_generated/net/client/citizen_request_client_packet.py

@@ -98,12 +98,16 @@ class CitizenRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CitizenRequestClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CitizenRequestClientPacket":

eolib/protocol/_generated/net/client/connection_accept_client_packet.py

@@ -115,15 +115,19 @@ class ConnectionAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ConnectionAcceptClientPacket): The data to serialize.
         """
-        if data._client_encryption_multiple is None:
-            raise SerializationError("client_encryption_multiple must be provided.")
-        writer.add_short(data._client_encryption_multiple)
-        if data._server_encryption_multiple is None:
-            raise SerializationError("server_encryption_multiple must be provided.")
-        writer.add_short(data._server_encryption_multiple)
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._client_encryption_multiple is None:
+                raise SerializationError("client_encryption_multiple must be provided.")
+            writer.add_short(data._client_encryption_multiple)
+            if data._server_encryption_multiple is None:
+                raise SerializationError("server_encryption_multiple must be provided.")
+            writer.add_short(data._server_encryption_multiple)
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ConnectionAcceptClientPacket":

eolib/protocol/_generated/net/client/connection_ping_client_packet.py

@@ -63,9 +63,11 @@ class ConnectionPingClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ConnectionPingClientPacket): 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_string("k")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ConnectionPingClientPacket":
@@ -82,8 +84,7 @@ class ConnectionPingClientPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

eolib/protocol/_generated/net/client/door_open_client_packet.py

@@ -74,9 +74,13 @@ class DoorOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (DoorOpenClientPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        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) -> "DoorOpenClientPacket":

eolib/protocol/_generated/net/client/emote_report_client_packet.py

@@ -74,9 +74,13 @@ class EmoteReportClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EmoteReportClientPacket): The data to serialize.
         """
-        if data._emote is None:
-            raise SerializationError("emote must be provided.")
-        writer.add_char(int(data._emote))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._emote is None:
+                raise SerializationError("emote must be provided.")
+            writer.add_char(int(data._emote))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EmoteReportClientPacket":

eolib/protocol/_generated/net/client/face_player_client_packet.py

@@ -74,9 +74,13 @@ class FacePlayerClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (FacePlayerClientPacket): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "FacePlayerClientPacket":

eolib/protocol/_generated/net/client/global_close_client_packet.py

@@ -63,9 +63,11 @@ class GlobalCloseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GlobalCloseClientPacket): 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_string("n")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GlobalCloseClientPacket":
@@ -82,8 +84,7 @@ class GlobalCloseClientPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

eolib/protocol/_generated/net/client/global_open_client_packet.py

@@ -63,9 +63,11 @@ class GlobalOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GlobalOpenClientPacket): 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_string("y")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GlobalOpenClientPacket":
@@ -82,8 +84,7 @@ class GlobalOpenClientPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

eolib/protocol/_generated/net/client/global_player_client_packet.py

@@ -63,9 +63,11 @@ class GlobalPlayerClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GlobalPlayerClientPacket): 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_string("y")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GlobalPlayerClientPacket":
@@ -82,8 +84,7 @@ class GlobalPlayerClientPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

eolib/protocol/_generated/net/client/global_remove_client_packet.py

@@ -63,9 +63,11 @@ class GlobalRemoveClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GlobalRemoveClientPacket): 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_string("n")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GlobalRemoveClientPacket":
@@ -82,8 +84,7 @@ class GlobalRemoveClientPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

eolib/protocol/_generated/net/client/guild_accept_client_packet.py

@@ -81,10 +81,14 @@ class GuildAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildAcceptClientPacket): The data to serialize.
         """
-        writer.add_int(20202)
-        if data._inviter_player_id is None:
-            raise SerializationError("inviter_player_id must be provided.")
-        writer.add_short(data._inviter_player_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_int(20202)
+            if data._inviter_player_id is None:
+                raise SerializationError("inviter_player_id must be provided.")
+            writer.add_short(data._inviter_player_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildAcceptClientPacket":