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

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

@@ -19,6 +19,10 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class InitInitServerPacket(Packet):
+    """
+    Reply to connection initialization and requests for unencrypted data.
+    This packet is unencrypted.
+    """
     _byte_size: int = 0
     _reply_code: InitReply = None # type: ignore [assignment]
     _reply_code_data: 'InitInitServerPacket.ReplyCodeData' = None
@@ -90,57 +94,61 @@ class InitInitServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (InitInitServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_byte(int(data._reply_code))
-        if data._reply_code == InitReply.OutOfDate:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOutOfDate):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOutOfDate for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataOutOfDate.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.Ok:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOk):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOk for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.Banned:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataBanned):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataBanned for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataBanned.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.WarpMap:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataWarpMap):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataWarpMap for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataWarpMap.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEmf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEmf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEmf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEmf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEif:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEif):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEif for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEif.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEnf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEnf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEnf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEnf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEsf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEsf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEsf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEsf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEcf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEcf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEcf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEcf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.MapMutation:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataMapMutation):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataMapMutation for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataMapMutation.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.PlayersList:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersList):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersList for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataPlayersList.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.PlayersListFriends:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersListFriends):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersListFriends for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataPlayersListFriends.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_byte(int(data._reply_code))
+            if data._reply_code == InitReply.OutOfDate:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOutOfDate):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOutOfDate for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataOutOfDate.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.Ok:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOk):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOk for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.Banned:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataBanned):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataBanned for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataBanned.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.WarpMap:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataWarpMap):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataWarpMap for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataWarpMap.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEmf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEmf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEmf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEmf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEif:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEif):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEif for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEif.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEnf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEnf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEnf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEnf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEsf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEsf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEsf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEsf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEcf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEcf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEcf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEcf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.MapMutation:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataMapMutation):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataMapMutation for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataMapMutation.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.PlayersList:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersList):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersList for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataPlayersList.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.PlayersListFriends:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersListFriends):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersListFriends for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataPlayersListFriends.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "InitInitServerPacket":
@@ -191,10 +199,9 @@ class InitInitServerPacket(Packet):
         return f"InitInitServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['InitInitServerPacket.ReplyCodeDataOutOfDate', 'InitInitServerPacket.ReplyCodeDataOk', 'InitInitServerPacket.ReplyCodeDataBanned', 'InitInitServerPacket.ReplyCodeDataWarpMap', 'InitInitServerPacket.ReplyCodeDataFileEmf', 'InitInitServerPacket.ReplyCodeDataFileEif', 'InitInitServerPacket.ReplyCodeDataFileEnf', 'InitInitServerPacket.ReplyCodeDataFileEsf', 'InitInitServerPacket.ReplyCodeDataFileEcf', 'InitInitServerPacket.ReplyCodeDataMapMutation', 'InitInitServerPacket.ReplyCodeDataPlayersList', 'InitInitServerPacket.ReplyCodeDataPlayersListFriends', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataOutOfDate:
         """
@@ -230,9 +237,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataOutOfDate): The data to serialize.
             """
-            if data._version is None:
-                raise SerializationError("version must be provided.")
-            Version.serialize(writer, data._version)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._version is None:
+                    raise SerializationError("version must be provided.")
+                Version.serialize(writer, data._version)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataOutOfDate":
@@ -385,24 +396,28 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataOk): The data to serialize.
             """
-            if data._seq1 is None:
-                raise SerializationError("seq1 must be provided.")
-            writer.add_byte(data._seq1)
-            if data._seq2 is None:
-                raise SerializationError("seq2 must be provided.")
-            writer.add_byte(data._seq2)
-            if data._server_encryption_multiple is None:
-                raise SerializationError("server_encryption_multiple must be provided.")
-            writer.add_byte(data._server_encryption_multiple)
-            if data._client_encryption_multiple is None:
-                raise SerializationError("client_encryption_multiple must be provided.")
-            writer.add_byte(data._client_encryption_multiple)
-            if data._player_id is None:
-                raise SerializationError("player_id must be provided.")
-            writer.add_short(data._player_id)
-            if data._challenge_response is None:
-                raise SerializationError("challenge_response must be provided.")
-            writer.add_three(data._challenge_response)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._seq1 is None:
+                    raise SerializationError("seq1 must be provided.")
+                writer.add_byte(data._seq1)
+                if data._seq2 is None:
+                    raise SerializationError("seq2 must be provided.")
+                writer.add_byte(data._seq2)
+                if data._server_encryption_multiple is None:
+                    raise SerializationError("server_encryption_multiple must be provided.")
+                writer.add_byte(data._server_encryption_multiple)
+                if data._client_encryption_multiple is None:
+                    raise SerializationError("client_encryption_multiple must be provided.")
+                writer.add_byte(data._client_encryption_multiple)
+                if data._player_id is None:
+                    raise SerializationError("player_id must be provided.")
+                writer.add_short(data._player_id)
+                if data._challenge_response is None:
+                    raise SerializationError("challenge_response must be provided.")
+                writer.add_three(data._challenge_response)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataOk":
@@ -479,17 +494,21 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataBanned): The data to serialize.
             """
-            if data._ban_type is None:
-                raise SerializationError("ban_type must be provided.")
-            writer.add_byte(int(data._ban_type))
-            if data._ban_type == 0:
-                if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0):
-                    raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0 for ban_type " + InitBanType(data._ban_type).name + ".")
-                InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.serialize(writer, data._ban_type_data)
-            elif data._ban_type == InitBanType.Temporary:
-                if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary):
-                    raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary for ban_type " + InitBanType(data._ban_type).name + ".")
-                InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.serialize(writer, data._ban_type_data)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._ban_type is None:
+                    raise SerializationError("ban_type must be provided.")
+                writer.add_byte(int(data._ban_type))
+                if data._ban_type == 0:
+                    if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0):
+                        raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0 for ban_type " + InitBanType(data._ban_type).name + ".")
+                    InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.serialize(writer, data._ban_type_data)
+                elif data._ban_type == InitBanType.Temporary:
+                    if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary):
+                        raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary for ban_type " + InitBanType(data._ban_type).name + ".")
+                    InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.serialize(writer, data._ban_type_data)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataBanned":
@@ -520,10 +539,9 @@ class InitInitServerPacket(Packet):
             return f"InitInitServerPacket.ReplyCodeDataBanned(byte_size={repr(self._byte_size)}, ban_type={repr(self._ban_type)}, ban_type_data={repr(self._ban_type_data)})"
 
         BanTypeData = Union['InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0', 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary', None]
-        BanTypeData.__doc__ = \
-            """
-            Data associated with different values of the `ban_type` field.
-            """
+        """
+        Data associated with different values of the `ban_type` field.
+        """
 
         class BanTypeData0:
             """
@@ -571,9 +589,13 @@ class InitInitServerPacket(Packet):
                     writer (EoWriter): The writer that the data will be serialized to.
                     data (InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0): The data to serialize.
                 """
-                if data._minutes_remaining is None:
-                    raise SerializationError("minutes_remaining must be provided.")
-                writer.add_byte(data._minutes_remaining)
+                old_string_sanitization_mode: bool = writer.string_sanitization_mode
+                try:
+                    if data._minutes_remaining is None:
+                        raise SerializationError("minutes_remaining must be provided.")
+                    writer.add_byte(data._minutes_remaining)
+                finally:
+                    writer.string_sanitization_mode = old_string_sanitization_mode
 
             @staticmethod
             def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0":
@@ -641,9 +663,13 @@ class InitInitServerPacket(Packet):
                     writer (EoWriter): The writer that the data will be serialized to.
                     data (InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary): The data to serialize.
                 """
-                if data._minutes_remaining is None:
-                    raise SerializationError("minutes_remaining must be provided.")
-                writer.add_byte(data._minutes_remaining)
+                old_string_sanitization_mode: bool = writer.string_sanitization_mode
+                try:
+                    if data._minutes_remaining is None:
+                        raise SerializationError("minutes_remaining must be provided.")
+                    writer.add_byte(data._minutes_remaining)
+                finally:
+                    writer.string_sanitization_mode = old_string_sanitization_mode
 
             @staticmethod
             def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary":
@@ -703,9 +729,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataWarpMap): The data to serialize.
             """
-            if data._map_file is None:
-                raise SerializationError("map_file must be provided.")
-            MapFile.serialize(writer, data._map_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_file is None:
+                    raise SerializationError("map_file must be provided.")
+                MapFile.serialize(writer, data._map_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataWarpMap":
@@ -765,9 +795,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEmf): The data to serialize.
             """
-            if data._map_file is None:
-                raise SerializationError("map_file must be provided.")
-            MapFile.serialize(writer, data._map_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_file is None:
+                    raise SerializationError("map_file must be provided.")
+                MapFile.serialize(writer, data._map_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEmf":
@@ -827,9 +861,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEif): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEif":
@@ -889,9 +927,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEnf): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEnf":
@@ -951,9 +993,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEsf): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEsf":
@@ -1013,9 +1059,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEcf): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEcf":
@@ -1075,9 +1125,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataMapMutation): The data to serialize.
             """
-            if data._map_file is None:
-                raise SerializationError("map_file must be provided.")
-            MapFile.serialize(writer, data._map_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_file is None:
+                    raise SerializationError("map_file must be provided.")
+                MapFile.serialize(writer, data._map_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataMapMutation":
@@ -1137,9 +1191,15 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataPlayersList): 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) -> "InitInitServerPacket.ReplyCodeDataPlayersList":
@@ -1201,9 +1261,15 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataPlayersListFriends): The data to serialize.
             """
-            if data._players_list is None:
-                raise SerializationError("players_list must be provided.")
-            PlayersListFriends.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.")
+                PlayersListFriends.serialize(writer, data._players_list)
+                writer.string_sanitization_mode = False
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataPlayersListFriends":

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

@@ -13,6 +13,9 @@ class InitReply(IntEnum, metaclass=ProtocolEnumMeta):
     OutOfDate = 1
     Ok = 2
     Banned = 3
+    """
+    The official client won't display a message until the connection from the server is closed
+    """
     WarpMap = 4
     FileEmf = 5
     FileEif = 6

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemAcceptServerPacket(Packet):
+    """
+    Nearby player leveled up from quest
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class ItemAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemAcceptServerPacket): 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) -> "ItemAcceptServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemAddServerPacket(Packet):
+    """
+    Item appeared on the ground
+    """
     _byte_size: int = 0
     _item_id: int = None # type: ignore [assignment]
     _item_index: int = None # type: ignore [assignment]
@@ -122,18 +125,22 @@ class ItemAddServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemAddServerPacket): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._item_index is None:
-            raise SerializationError("item_index must be provided.")
-        writer.add_short(data._item_index)
-        if data._item_amount is None:
-            raise SerializationError("item_amount must be provided.")
-        writer.add_three(data._item_amount)
-        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._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._item_index is None:
+                raise SerializationError("item_index must be provided.")
+            writer.add_short(data._item_index)
+            if data._item_amount is None:
+                raise SerializationError("item_amount must be provided.")
+            writer.add_three(data._item_amount)
+            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) -> "ItemAddServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemAgreeServerPacket(Packet):
+    """
+    Reply to using an item that you don't have
+    """
     _byte_size: int = 0
     _item_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class ItemAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemAgreeServerPacket): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemAgreeServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ItemDropServerPacket(Packet):
+    """
+    Reply to dropping items on the ground
+    """
     _byte_size: int = 0
     _dropped_item: ThreeItem = None # type: ignore [assignment]
     _remaining_amount: int = None # type: ignore [assignment]
@@ -125,21 +128,25 @@ class ItemDropServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemDropServerPacket): The data to serialize.
         """
-        if data._dropped_item is None:
-            raise SerializationError("dropped_item must be provided.")
-        ThreeItem.serialize(writer, data._dropped_item)
-        if data._remaining_amount is None:
-            raise SerializationError("remaining_amount must be provided.")
-        writer.add_int(data._remaining_amount)
-        if data._item_index is None:
-            raise SerializationError("item_index must be provided.")
-        writer.add_short(data._item_index)
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._dropped_item is None:
+                raise SerializationError("dropped_item must be provided.")
+            ThreeItem.serialize(writer, data._dropped_item)
+            if data._remaining_amount is None:
+                raise SerializationError("remaining_amount must be provided.")
+            writer.add_int(data._remaining_amount)
+            if data._item_index is None:
+                raise SerializationError("item_index must be provided.")
+            writer.add_short(data._item_index)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemDropServerPacket":