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

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class JukeboxReplyServerPacket(Packet):
+    """
+    Reply to unsuccessfully requesting a song
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class JukeboxReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxReplyServerPacket): 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(1)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxReplyServerPacket":
@@ -79,8 +84,7 @@ class JukeboxReplyServerPacket(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/jukebox_use_server_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class JukeboxUseServerPacket(Packet):
+    """
+    Play jukebox music
+    """
     _byte_size: int = 0
     _track_id: int = None # type: ignore [assignment]
 
@@ -27,6 +30,8 @@ class JukeboxUseServerPacket(Packet):
     @property
     def track_id(self) -> int:
         """
+        This value is 1-indexed
+
         Note:
           - Value range is 0-64008.
         """
@@ -35,6 +40,8 @@ class JukeboxUseServerPacket(Packet):
     @track_id.setter
     def track_id(self, track_id: int) -> None:
         """
+        This value is 1-indexed
+
         Note:
           - Value range is 0-64008.
         """
@@ -78,9 +85,13 @@ class JukeboxUseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (JukeboxUseServerPacket): The data to serialize.
         """
-        if data._track_id is None:
-            raise SerializationError("track_id must be provided.")
-        writer.add_short(data._track_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._track_id is None:
+                raise SerializationError("track_id must be provided.")
+            writer.add_short(data._track_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "JukeboxUseServerPacket":

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

@@ -134,24 +134,28 @@ class LevelUpStats:
             writer (EoWriter): The writer that the data will be serialized to.
             data (LevelUpStats): The data to serialize.
         """
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LevelUpStats":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class LockerBuyServerPacket(Packet):
+    """
+    Response to buying a locker space upgrade from a banker NPC
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
     _locker_upgrades: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class LockerBuyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (LockerBuyServerPacket): The data to serialize.
         """
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
-        if data._locker_upgrades is None:
-            raise SerializationError("locker_upgrades must be provided.")
-        writer.add_char(data._locker_upgrades)
+        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)
+            if data._locker_upgrades is None:
+                raise SerializationError("locker_upgrades must be provided.")
+            writer.add_char(data._locker_upgrades)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "LockerBuyServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class LockerGetServerPacket(Packet):
+    """
+    Response to taking an item from a bank locker
+    """
     _byte_size: int = 0
     _taken_item: ThreeItem = None # type: ignore [assignment]
     _weight: Weight = None # type: ignore [assignment]
@@ -91,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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class LockerOpenServerPacket(Packet):
+    """
+    Opening a bank locker
+    """
     _byte_size: int = 0
     _locker_coords: Coords = None # type: ignore [assignment]
     _locker_items: list[ThreeItem] = None # type: ignore [assignment]
@@ -82,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

@@ -15,6 +15,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class LockerReplyServerPacket(Packet):
+    """
+    Response to adding an item to a bank locker
+    """
     _byte_size: int = 0
     _deposited_item: Item = None # type: ignore [assignment]
     _weight: Weight = None # type: ignore [assignment]
@@ -92,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class LockerSpecServerPacket(Packet):
+    """
+    Reply to trying to add an item to a full locker
+    """
     _byte_size: int = 0
     _locker_max_items: int = None # type: ignore [assignment]
 
@@ -78,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

@@ -15,6 +15,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class LoginReplyServerPacket(Packet):
+    """
+    Login reply
+    """
     _byte_size: int = 0
     _reply_code: LoginReply = None # type: ignore [assignment]
     _reply_code_data: 'LoginReplyServerPacket.ReplyCodeData' = None
@@ -86,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":
@@ -153,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:
         """
@@ -184,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":
@@ -236,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":
@@ -306,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":
@@ -341,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:
@@ -377,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":
@@ -429,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":
@@ -481,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class MarriageOpenServerPacket(Packet):
+    """
+    Response from talking to a law NPC
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
 
@@ -78,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":