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

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

@@ -94,16 +94,20 @@ class LockerGetServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (LockerGetServerPacket): The data to serialize.
         """
-        if data._taken_item is None:
-            raise SerializationError("taken_item must be provided.")
-        ThreeItem.serialize(writer, data._taken_item)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._locker_items is None:
-            raise SerializationError("locker_items must be provided.")
-        for i in range(len(data._locker_items)):
-            ThreeItem.serialize(writer, data._locker_items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._taken_item is None:
+                raise SerializationError("taken_item must be provided.")
+            ThreeItem.serialize(writer, data._taken_item)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._locker_items is None:
+                raise SerializationError("locker_items must be provided.")
+            for i in range(len(data._locker_items)):
+                ThreeItem.serialize(writer, data._locker_items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LockerGetServerPacket":

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

@@ -85,13 +85,17 @@ class LockerOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (LockerOpenServerPacket): The data to serialize.
         """
-        if data._locker_coords is None:
-            raise SerializationError("locker_coords must be provided.")
-        Coords.serialize(writer, data._locker_coords)
-        if data._locker_items is None:
-            raise SerializationError("locker_items must be provided.")
-        for i in range(len(data._locker_items)):
-            ThreeItem.serialize(writer, data._locker_items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._locker_coords is None:
+                raise SerializationError("locker_coords must be provided.")
+            Coords.serialize(writer, data._locker_coords)
+            if data._locker_items is None:
+                raise SerializationError("locker_items must be provided.")
+            for i in range(len(data._locker_items)):
+                ThreeItem.serialize(writer, data._locker_items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LockerOpenServerPacket":

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

@@ -95,16 +95,20 @@ class LockerReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (LockerReplyServerPacket): The data to serialize.
         """
-        if data._deposited_item is None:
-            raise SerializationError("deposited_item must be provided.")
-        Item.serialize(writer, data._deposited_item)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._locker_items is None:
-            raise SerializationError("locker_items must be provided.")
-        for i in range(len(data._locker_items)):
-            ThreeItem.serialize(writer, data._locker_items[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._deposited_item is None:
+                raise SerializationError("deposited_item must be provided.")
+            Item.serialize(writer, data._deposited_item)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._locker_items is None:
+                raise SerializationError("locker_items must be provided.")
+            for i in range(len(data._locker_items)):
+                ThreeItem.serialize(writer, data._locker_items[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LockerReplyServerPacket":

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

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

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

@@ -15,5 +15,11 @@ class LoginReply(IntEnum, metaclass=ProtocolEnumMeta):
     WrongUserPassword = 2
     Ok = 3
     Banned = 4
+    """
+    The official client won't display a message until the connection from the server is closed
+    """
     LoggedIn = 5
     Busy = 6
+    """
+    The official client won't display a message until the connection from the server is closed
+    """

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

@@ -89,33 +89,39 @@ class LoginReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (LoginReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == LoginReply.WrongUser:
-            if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataWrongUser):
-                raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataWrongUser for reply_code " + LoginReply(data._reply_code).name + ".")
-            LoginReplyServerPacket.ReplyCodeDataWrongUser.serialize(writer, data._reply_code_data)
-        elif data._reply_code == LoginReply.WrongUserPassword:
-            if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataWrongUserPassword):
-                raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataWrongUserPassword for reply_code " + LoginReply(data._reply_code).name + ".")
-            LoginReplyServerPacket.ReplyCodeDataWrongUserPassword.serialize(writer, data._reply_code_data)
-        elif data._reply_code == LoginReply.Ok:
-            if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataOk):
-                raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataOk for reply_code " + LoginReply(data._reply_code).name + ".")
-            LoginReplyServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
-        elif data._reply_code == LoginReply.Banned:
-            if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataBanned):
-                raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataBanned for reply_code " + LoginReply(data._reply_code).name + ".")
-            LoginReplyServerPacket.ReplyCodeDataBanned.serialize(writer, data._reply_code_data)
-        elif data._reply_code == LoginReply.LoggedIn:
-            if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataLoggedIn):
-                raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataLoggedIn for reply_code " + LoginReply(data._reply_code).name + ".")
-            LoginReplyServerPacket.ReplyCodeDataLoggedIn.serialize(writer, data._reply_code_data)
-        elif data._reply_code == LoginReply.Busy:
-            if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataBusy):
-                raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataBusy for reply_code " + LoginReply(data._reply_code).name + ".")
-            LoginReplyServerPacket.ReplyCodeDataBusy.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+            if data._reply_code == LoginReply.WrongUser:
+                if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataWrongUser):
+                    raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataWrongUser for reply_code " + LoginReply(data._reply_code).name + ".")
+                LoginReplyServerPacket.ReplyCodeDataWrongUser.serialize(writer, data._reply_code_data)
+            elif data._reply_code == LoginReply.WrongUserPassword:
+                if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataWrongUserPassword):
+                    raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataWrongUserPassword for reply_code " + LoginReply(data._reply_code).name + ".")
+                LoginReplyServerPacket.ReplyCodeDataWrongUserPassword.serialize(writer, data._reply_code_data)
+            elif data._reply_code == LoginReply.Ok:
+                if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataOk):
+                    raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataOk for reply_code " + LoginReply(data._reply_code).name + ".")
+                LoginReplyServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
+            elif data._reply_code == LoginReply.Banned:
+                if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataBanned):
+                    raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataBanned for reply_code " + LoginReply(data._reply_code).name + ".")
+                LoginReplyServerPacket.ReplyCodeDataBanned.serialize(writer, data._reply_code_data)
+            elif data._reply_code == LoginReply.LoggedIn:
+                if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataLoggedIn):
+                    raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataLoggedIn for reply_code " + LoginReply(data._reply_code).name + ".")
+                LoginReplyServerPacket.ReplyCodeDataLoggedIn.serialize(writer, data._reply_code_data)
+            elif data._reply_code == LoginReply.Busy:
+                if not isinstance(data._reply_code_data, LoginReplyServerPacket.ReplyCodeDataBusy):
+                    raise SerializationError("Expected reply_code_data to be type LoginReplyServerPacket.ReplyCodeDataBusy for reply_code " + LoginReply(data._reply_code).name + ".")
+                LoginReplyServerPacket.ReplyCodeDataBusy.serialize(writer, data._reply_code_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LoginReplyServerPacket":
@@ -156,10 +162,9 @@ class LoginReplyServerPacket(Packet):
         return f"LoginReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['LoginReplyServerPacket.ReplyCodeDataWrongUser', 'LoginReplyServerPacket.ReplyCodeDataWrongUserPassword', 'LoginReplyServerPacket.ReplyCodeDataOk', 'LoginReplyServerPacket.ReplyCodeDataBanned', 'LoginReplyServerPacket.ReplyCodeDataLoggedIn', 'LoginReplyServerPacket.ReplyCodeDataBusy', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataWrongUser:
         """
@@ -187,7 +192,11 @@ class LoginReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (LoginReplyServerPacket.ReplyCodeDataWrongUser): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "LoginReplyServerPacket.ReplyCodeDataWrongUser":
@@ -239,7 +248,11 @@ class LoginReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (LoginReplyServerPacket.ReplyCodeDataWrongUserPassword): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "LoginReplyServerPacket.ReplyCodeDataWrongUserPassword":
@@ -309,19 +322,22 @@ class LoginReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (LoginReplyServerPacket.ReplyCodeDataOk): The data to serialize.
             """
-            if data._characters_count is None:
-                raise SerializationError("characters_count must be provided.")
-            writer.add_char(data._characters_count)
-            writer.add_char(0)
-            writer.add_byte(0xFF)
-            if data._characters is None:
-                raise SerializationError("characters must be provided.")
-            if len(data._characters) > 252:
-                raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
-            for i in range(data._characters_count):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._characters_count is None:
+                    raise SerializationError("characters_count must be provided.")
+                writer.add_char(data._characters_count)
+                writer.add_char(0)
+                writer.add_byte(0xFF)
+                if data._characters is None:
+                    raise SerializationError("characters must be provided.")
+                if len(data._characters) > 252:
+                    raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
+                for i in range(data._characters_count):
+                    CharacterSelectionListEntry.serialize(writer, data._characters[i])
                     writer.add_byte(0xFF)
-                CharacterSelectionListEntry.serialize(writer, data._characters[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "LoginReplyServerPacket.ReplyCodeDataOk":
@@ -344,8 +360,7 @@ class LoginReplyServerPacket(Packet):
                 data._characters = []
                 for i in range(data._characters_count):
                     data._characters.append(CharacterSelectionListEntry.deserialize(reader))
-                    if i + 1 < data._characters_count:
-                        reader.next_chunk()
+                    reader.next_chunk()
                 data._byte_size = reader.position - reader_start_position
                 return data
             finally:
@@ -380,7 +395,11 @@ class LoginReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (LoginReplyServerPacket.ReplyCodeDataBanned): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "LoginReplyServerPacket.ReplyCodeDataBanned":
@@ -432,7 +451,11 @@ class LoginReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (LoginReplyServerPacket.ReplyCodeDataLoggedIn): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "LoginReplyServerPacket.ReplyCodeDataLoggedIn":
@@ -484,7 +507,11 @@ class LoginReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (LoginReplyServerPacket.ReplyCodeDataBusy): The data to serialize.
             """
-            writer.add_string("NO")
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.add_string("NO")
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "LoginReplyServerPacket.ReplyCodeDataBusy":

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

@@ -83,15 +83,19 @@ class MapDrainDamageOther:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapDrainDamageOther): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_short(data._damage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_short(data._damage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapDrainDamageOther":

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

@@ -41,9 +41,13 @@ class MapFile:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapFile): The data to serialize.
         """
-        if data._content is None:
-            raise SerializationError("content must be provided.")
-        writer.add_bytes(data._content)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._content is None:
+                raise SerializationError("content must be provided.")
+            writer.add_bytes(data._content)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapFile":

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

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

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

@@ -87,13 +87,17 @@ class MarriageReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MarriageReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == MarriageReply.Success:
-            if not isinstance(data._reply_code_data, MarriageReplyServerPacket.ReplyCodeDataSuccess):
-                raise SerializationError("Expected reply_code_data to be type MarriageReplyServerPacket.ReplyCodeDataSuccess for reply_code " + MarriageReply(data._reply_code).name + ".")
-            MarriageReplyServerPacket.ReplyCodeDataSuccess.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_short(int(data._reply_code))
+            if data._reply_code == MarriageReply.Success:
+                if not isinstance(data._reply_code_data, MarriageReplyServerPacket.ReplyCodeDataSuccess):
+                    raise SerializationError("Expected reply_code_data to be type MarriageReplyServerPacket.ReplyCodeDataSuccess for reply_code " + MarriageReply(data._reply_code).name + ".")
+                MarriageReplyServerPacket.ReplyCodeDataSuccess.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MarriageReplyServerPacket":
@@ -122,10 +126,9 @@ class MarriageReplyServerPacket(Packet):
         return f"MarriageReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['MarriageReplyServerPacket.ReplyCodeDataSuccess', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataSuccess:
         """
@@ -169,9 +172,13 @@ class MarriageReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (MarriageReplyServerPacket.ReplyCodeDataSuccess): The data to serialize.
             """
-            if data._gold_amount is None:
-                raise SerializationError("gold_amount must be provided.")
-            writer.add_int(data._gold_amount)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._gold_amount is None:
+                    raise SerializationError("gold_amount must be provided.")
+                writer.add_int(data._gold_amount)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "MarriageReplyServerPacket.ReplyCodeDataSuccess":

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

@@ -82,14 +82,19 @@ class MessageAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageAcceptServerPacket): The data to serialize.
         """
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        if len(data._messages) != 4:
-            raise SerializationError(f"Expected length of messages to be exactly 4, got {len(data._messages)}.")
-        for i in range(4):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            if len(data._messages) != 4:
+                raise SerializationError(f"Expected length of messages to be exactly 4, got {len(data._messages)}.")
+            for i in range(4):
+                writer.add_string(data._messages[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._messages[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessageAcceptServerPacket":
@@ -110,8 +115,7 @@ class MessageAcceptServerPacket(Packet):
             data._messages = []
             for i in range(4):
                 data._messages.append(reader.get_string())
-                if i + 1 < 4:
-                    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/message_close_server_packet.py

@@ -63,9 +63,11 @@ class MessageCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageCloseServerPacket): 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("r")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessageCloseServerPacket":
@@ -82,8 +84,7 @@ class MessageCloseServerPacket(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/server/message_open_server_packet.py

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

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

@@ -63,9 +63,11 @@ class MessagePongServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessagePongServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_short(2)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessagePongServerPacket":
@@ -82,8 +84,7 @@ class MessagePongServerPacket(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_short()
+            reader.get_short()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

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

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

@@ -73,27 +73,32 @@ class NearbyInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NearbyInfo): The data to serialize.
         """
-        if data._characters_count is None:
-            raise SerializationError("characters_count must be provided.")
-        writer.add_char(data._characters_count)
-        writer.add_byte(0xFF)
-        if data._characters is None:
-            raise SerializationError("characters must be provided.")
-        if len(data._characters) > 252:
-            raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
-        for i in range(data._characters_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._characters_count is None:
+                raise SerializationError("characters_count must be provided.")
+            writer.add_char(data._characters_count)
+            writer.string_sanitization_mode = True
+            writer.add_byte(0xFF)
+            if data._characters is None:
+                raise SerializationError("characters must be provided.")
+            if len(data._characters) > 252:
+                raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
+            for i in range(data._characters_count):
+                CharacterMapInfo.serialize(writer, data._characters[i])
                 writer.add_byte(0xFF)
-            CharacterMapInfo.serialize(writer, data._characters[i])
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        for i in range(len(data._npcs)):
-            NpcMapInfo.serialize(writer, data._npcs[i])
-        writer.add_byte(0xFF)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ItemMapInfo.serialize(writer, data._items[i])
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            for i in range(len(data._npcs)):
+                NpcMapInfo.serialize(writer, data._npcs[i])
+            writer.add_byte(0xFF)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ItemMapInfo.serialize(writer, data._items[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NearbyInfo":
@@ -116,8 +121,7 @@ class NearbyInfo:
             data._characters = []
             for i in range(data._characters_count):
                 data._characters.append(CharacterMapInfo.deserialize(reader))
-                if i + 1 < data._characters_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             npcs_length = int(reader.remaining / 6)
             data._npcs = []
             for i in range(npcs_length):