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

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

@@ -118,18 +118,22 @@ class PaperdollRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollRemoveServerPacket): The data to serialize.
         """
-        if data._change is None:
-            raise SerializationError("change must be provided.")
-        AvatarChange.serialize(writer, data._change)
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._sub_loc is None:
-            raise SerializationError("sub_loc must be provided.")
-        writer.add_char(data._sub_loc)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsEquipmentChange.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._change is None:
+                raise SerializationError("change must be provided.")
+            AvatarChange.serialize(writer, data._change)
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._sub_loc is None:
+                raise SerializationError("sub_loc must be provided.")
+            writer.add_char(data._sub_loc)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsEquipmentChange.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollRemoveServerPacket":

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

@@ -94,15 +94,21 @@ class PaperdollReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollReplyServerPacket): The data to serialize.
         """
-        if data._details is None:
-            raise SerializationError("details must be provided.")
-        CharacterDetails.serialize(writer, data._details)
-        if data._equipment is None:
-            raise SerializationError("equipment must be provided.")
-        EquipmentPaperdoll.serialize(writer, data._equipment)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._details is None:
+                raise SerializationError("details must be provided.")
+            CharacterDetails.serialize(writer, data._details)
+            if data._equipment is None:
+                raise SerializationError("equipment must be provided.")
+            EquipmentPaperdoll.serialize(writer, data._equipment)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollReplyServerPacket":

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

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

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

@@ -98,12 +98,16 @@ class PartyAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyAgreeServerPacket): 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)
+        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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyAgreeServerPacket":

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

@@ -63,9 +63,11 @@ class PartyCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyCloseServerPacket): 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_byte(255)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyCloseServerPacket":
@@ -82,8 +84,7 @@ class PartyCloseServerPacket(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_byte()
+            reader.get_byte()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -75,12 +75,17 @@ class PartyCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyCreateServerPacket): The data to serialize.
         """
-        if data._members is None:
-            raise SerializationError("members must be provided.")
-        for i in range(len(data._members)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._members is None:
+                raise SerializationError("members must be provided.")
+            for i in range(len(data._members)):
+                PartyMember.serialize(writer, data._members[i])
                 writer.add_byte(0xFF)
-            PartyMember.serialize(writer, data._members[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyCreateServerPacket":

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

@@ -9,7 +9,7 @@ from .....data.eo_reader import EoReader
 
 class PartyExpShare:
     """
-    EXP gain for a member of the player's party
+    EXP gain for a member of the player's party
     """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
@@ -61,7 +61,7 @@ class PartyExpShare:
     @property
     def level_up(self) -> int:
         """
-        A value greater than 0 is "new level" and indicates the player leveled up.
+        A value greater than 0 is "new level" and indicates the player leveled up.
 
         Note:
           - Value range is 0-252.
@@ -71,7 +71,7 @@ class PartyExpShare:
     @level_up.setter
     def level_up(self, level_up: int) -> None:
         """
-        A value greater than 0 is "new level" and indicates the player leveled up.
+        A value greater than 0 is "new level" and indicates the player leveled up.
 
         Note:
           - Value range is 0-252.
@@ -87,15 +87,19 @@ class PartyExpShare:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyExpShare): 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._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.")
-        writer.add_char(data._level_up)
+        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._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.")
+            writer.add_char(data._level_up)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyExpShare":

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

@@ -75,12 +75,17 @@ class PartyListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyListServerPacket): The data to serialize.
         """
-        if data._members is None:
-            raise SerializationError("members must be provided.")
-        for i in range(len(data._members)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._members is None:
+                raise SerializationError("members must be provided.")
+            for i in range(len(data._members)):
+                PartyMember.serialize(writer, data._members[i])
                 writer.add_byte(0xFF)
-            PartyMember.serialize(writer, data._members[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyListServerPacket":

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

@@ -9,7 +9,7 @@ from .....data.eo_reader import EoReader
 
 class PartyMember:
     """
-    A member of the player's party
+    A member of the player's party
     """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
@@ -101,21 +101,25 @@ class PartyMember:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyMember): 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._leader is None:
-            raise SerializationError("leader must be provided.")
-        writer.add_char(1 if data._leader else 0)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        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._leader is None:
+                raise SerializationError("leader must be provided.")
+            writer.add_char(1 if data._leader else 0)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyMember":

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

@@ -81,9 +81,13 @@ class PartyRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyRemoveServerPacket): The data to serialize.
         """
-        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._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) -> "PartyRemoveServerPacket":

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

@@ -87,17 +87,21 @@ class PartyReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_char(int(data._reply_code))
-        if data._reply_code == PartyReplyCode.AlreadyInAnotherParty:
-            if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty):
-                raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
-            PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty.serialize(writer, data._reply_code_data)
-        elif data._reply_code == PartyReplyCode.AlreadyInYourParty:
-            if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty):
-                raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
-            PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_char(int(data._reply_code))
+            if data._reply_code == PartyReplyCode.AlreadyInAnotherParty:
+                if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty):
+                    raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
+                PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty.serialize(writer, data._reply_code_data)
+            elif data._reply_code == PartyReplyCode.AlreadyInYourParty:
+                if not isinstance(data._reply_code_data, PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty):
+                    raise SerializationError("Expected reply_code_data to be type PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty for reply_code " + PartyReplyCode(data._reply_code).name + ".")
+                PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyReplyServerPacket":
@@ -128,10 +132,9 @@ class PartyReplyServerPacket(Packet):
         return f"PartyReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty', 'PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataAlreadyInAnotherParty:
         """
@@ -167,9 +170,13 @@ class PartyReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty): The data to serialize.
             """
-            if data._player_name is None:
-                raise SerializationError("player_name must be provided.")
-            writer.add_string(data._player_name)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._player_name is None:
+                    raise SerializationError("player_name must be provided.")
+                writer.add_string(data._player_name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "PartyReplyServerPacket.ReplyCodeDataAlreadyInAnotherParty":
@@ -229,9 +236,13 @@ class PartyReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty): The data to serialize.
             """
-            if data._player_name is None:
-                raise SerializationError("player_name must be provided.")
-            writer.add_string(data._player_name)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._player_name is None:
+                    raise SerializationError("player_name must be provided.")
+                writer.add_string(data._player_name)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "PartyReplyServerPacket.ReplyCodeDataAlreadyInYourParty":

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

@@ -100,15 +100,19 @@ class PartyRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyRequestServerPacket): The data to serialize.
         """
-        if data._request_type is None:
-            raise SerializationError("request_type must be provided.")
-        writer.add_char(int(data._request_type))
-        if data._inviter_player_id is None:
-            raise SerializationError("inviter_player_id must be provided.")
-        writer.add_short(data._inviter_player_id)
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._request_type is None:
+                raise SerializationError("request_type must be provided.")
+            writer.add_char(int(data._request_type))
+            if data._inviter_player_id is None:
+                raise SerializationError("inviter_player_id must be provided.")
+            writer.add_short(data._inviter_player_id)
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyRequestServerPacket":

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

@@ -75,10 +75,14 @@ class PartyTargetGroupServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyTargetGroupServerPacket): The data to serialize.
         """
-        if data._gains is None:
-            raise SerializationError("gains must be provided.")
-        for i in range(len(data._gains)):
-            PartyExpShare.serialize(writer, data._gains[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._gains is None:
+                raise SerializationError("gains must be provided.")
+            for i in range(len(data._gains)):
+                PartyExpShare.serialize(writer, data._gains[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyTargetGroupServerPacket":

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

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

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

@@ -53,18 +53,23 @@ class PlayersList:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersList): The data to serialize.
         """
-        if data._players_count is None:
-            raise SerializationError("players_count must be provided.")
-        writer.add_short(data._players_count)
-        writer.add_byte(0xFF)
-        if data._players is None:
-            raise SerializationError("players must be provided.")
-        if len(data._players) > 64008:
-            raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
-        for i in range(data._players_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_count is None:
+                raise SerializationError("players_count must be provided.")
+            writer.add_short(data._players_count)
+            writer.add_byte(0xFF)
+            if data._players is None:
+                raise SerializationError("players must be provided.")
+            if len(data._players) > 64008:
+                raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
+            for i in range(data._players_count):
+                OnlinePlayer.serialize(writer, data._players[i])
                 writer.add_byte(0xFF)
-            OnlinePlayer.serialize(writer, data._players[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersList":
@@ -87,8 +92,7 @@ class PlayersList:
             data._players = []
             for i in range(data._players_count):
                 data._players.append(OnlinePlayer.deserialize(reader))
-                if i + 1 < data._players_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -53,18 +53,23 @@ class PlayersListFriends:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersListFriends): The data to serialize.
         """
-        if data._players_count is None:
-            raise SerializationError("players_count must be provided.")
-        writer.add_short(data._players_count)
-        writer.add_byte(0xFF)
-        if data._players is None:
-            raise SerializationError("players must be provided.")
-        if len(data._players) > 64008:
-            raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
-        for i in range(data._players_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_count is None:
+                raise SerializationError("players_count must be provided.")
+            writer.add_short(data._players_count)
+            writer.add_byte(0xFF)
+            if data._players is None:
+                raise SerializationError("players must be provided.")
+            if len(data._players) > 64008:
+                raise SerializationError(f"Expected length of players to be 64008 or less, got {len(data._players)}.")
+            for i in range(data._players_count):
+                writer.add_string(data._players[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._players[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersListFriends":
@@ -87,8 +92,7 @@ class PlayersListFriends:
             data._players = []
             for i in range(data._players_count):
                 data._players.append(reader.get_string())
-                if i + 1 < data._players_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -74,9 +74,15 @@ class PlayersListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PlayersListServerPacket): The data to serialize.
         """
-        if data._players_list is None:
-            raise SerializationError("players_list must be provided.")
-        PlayersList.serialize(writer, data._players_list)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._players_list is None:
+                raise SerializationError("players_list must be provided.")
+            PlayersList.serialize(writer, data._players_list)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PlayersListServerPacket":

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

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

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

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

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

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