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

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

@@ -101,15 +101,19 @@ class NpcAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcAcceptServerPacket): The data to serialize.
         """
-        if data._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        if data._experience is None:
-            raise SerializationError("experience must be provided.")
-        writer.add_int(data._experience)
-        if data._level_up is None:
-            raise SerializationError("level_up must be provided.")
-        LevelUpStats.serialize(writer, data._level_up)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            if data._experience is None:
+                raise SerializationError("experience must be provided.")
+            writer.add_int(data._experience)
+            if data._level_up is None:
+                raise SerializationError("level_up must be provided.")
+            LevelUpStats.serialize(writer, data._level_up)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcAcceptServerPacket":

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

@@ -34,7 +34,7 @@ class NpcAgreeServerPacket(Packet):
     def npcs(self) -> list[NpcMapInfo]:
         """
         Note:
-          - Length must be 64008 or less.
+          - Length must be 252 or less.
         """
         return self._npcs
 
@@ -42,7 +42,7 @@ class NpcAgreeServerPacket(Packet):
     def npcs(self, npcs: list[NpcMapInfo]) -> None:
         """
         Note:
-          - Length must be 64008 or less.
+          - Length must be 252 or less.
         """
         self._npcs = npcs
         self._npcs_count = len(self._npcs)
@@ -85,15 +85,19 @@ class NpcAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcAgreeServerPacket): The data to serialize.
         """
-        if data._npcs_count is None:
-            raise SerializationError("npcs_count must be provided.")
-        writer.add_short(data._npcs_count)
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        if len(data._npcs) > 64008:
-            raise SerializationError(f"Expected length of npcs to be 64008 or less, got {len(data._npcs)}.")
-        for i in range(data._npcs_count):
-            NpcMapInfo.serialize(writer, data._npcs[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npcs_count is None:
+                raise SerializationError("npcs_count must be provided.")
+            writer.add_char(data._npcs_count)
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            if len(data._npcs) > 252:
+                raise SerializationError(f"Expected length of npcs to be 252 or less, got {len(data._npcs)}.")
+            for i in range(data._npcs_count):
+                NpcMapInfo.serialize(writer, data._npcs[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcAgreeServerPacket":
@@ -110,7 +114,7 @@ class NpcAgreeServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._npcs_count = reader.get_short()
+            data._npcs_count = reader.get_char()
             data._npcs = []
             for i in range(data._npcs_count):
                 data._npcs.append(NpcMapInfo.deserialize(reader))

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

@@ -90,12 +90,16 @@ class NpcDialogServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcDialogServerPacket): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        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._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            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) -> "NpcDialogServerPacket":

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

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

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

@@ -154,30 +154,34 @@ class NpcKilledData:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcKilledData): The data to serialize.
         """
-        if data._killer_id is None:
-            raise SerializationError("killer_id must be provided.")
-        writer.add_short(data._killer_id)
-        if data._killer_direction is None:
-            raise SerializationError("killer_direction must be provided.")
-        writer.add_char(int(data._killer_direction))
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        if data._drop_index is None:
-            raise SerializationError("drop_index must be provided.")
-        writer.add_short(data._drop_index)
-        if data._drop_id is None:
-            raise SerializationError("drop_id must be provided.")
-        writer.add_short(data._drop_id)
-        if data._drop_coords is None:
-            raise SerializationError("drop_coords must be provided.")
-        Coords.serialize(writer, data._drop_coords)
-        if data._drop_amount is None:
-            raise SerializationError("drop_amount must be provided.")
-        writer.add_int(data._drop_amount)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._killer_id is None:
+                raise SerializationError("killer_id must be provided.")
+            writer.add_short(data._killer_id)
+            if data._killer_direction is None:
+                raise SerializationError("killer_direction must be provided.")
+            writer.add_char(int(data._killer_direction))
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            if data._drop_index is None:
+                raise SerializationError("drop_index must be provided.")
+            writer.add_short(data._drop_index)
+            if data._drop_id is None:
+                raise SerializationError("drop_id must be provided.")
+            writer.add_short(data._drop_id)
+            if data._drop_coords is None:
+                raise SerializationError("drop_coords must be provided.")
+            Coords.serialize(writer, data._drop_coords)
+            if data._drop_amount is None:
+                raise SerializationError("drop_amount must be provided.")
+            writer.add_int(data._drop_amount)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcKilledData":

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

@@ -86,18 +86,22 @@ class NpcMapInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcMapInfo): The data to serialize.
         """
-        if data._index is None:
-            raise SerializationError("index must be provided.")
-        writer.add_char(data._index)
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._index is None:
+                raise SerializationError("index must be provided.")
+            writer.add_char(data._index)
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcMapInfo":

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

@@ -131,27 +131,33 @@ class NpcPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcPlayerServerPacket): The data to serialize.
         """
-        if data._positions is None:
-            raise SerializationError("positions must be provided.")
-        for i in range(len(data._positions)):
-            NpcUpdatePosition.serialize(writer, data._positions[i])
-        writer.add_byte(0xFF)
-        if data._attacks is None:
-            raise SerializationError("attacks must be provided.")
-        for i in range(len(data._attacks)):
-            NpcUpdateAttack.serialize(writer, data._attacks[i])
-        writer.add_byte(0xFF)
-        if data._chats is None:
-            raise SerializationError("chats must be provided.")
-        for i in range(len(data._chats)):
-            NpcUpdateChat.serialize(writer, data._chats[i])
-        writer.add_byte(0xFF)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
-        reached_missing_optional = reached_missing_optional or data._tp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._tp))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._positions is None:
+                raise SerializationError("positions must be provided.")
+            for i in range(len(data._positions)):
+                NpcUpdatePosition.serialize(writer, data._positions[i])
+            writer.add_byte(0xFF)
+            if data._attacks is None:
+                raise SerializationError("attacks must be provided.")
+            for i in range(len(data._attacks)):
+                NpcUpdateAttack.serialize(writer, data._attacks[i])
+            writer.add_byte(0xFF)
+            if data._chats is None:
+                raise SerializationError("chats must be provided.")
+            for i in range(len(data._chats)):
+                NpcUpdateChat.serialize(writer, data._chats[i])
+            writer.add_byte(0xFF)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+            reached_missing_optional = reached_missing_optional or data._tp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._tp))
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcPlayerServerPacket":

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

@@ -154,24 +154,28 @@ class NpcReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcReplyServerPacket): 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._player_direction is None:
-            raise SerializationError("player_direction must be provided.")
-        writer.add_char(int(data._player_direction))
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_short(data._hp_percentage)
-        reached_missing_optional = data._kill_steal_protection is None
-        if not reached_missing_optional:
-            writer.add_char(int(cast(NpcKillStealProtectionState, data._kill_steal_protection)))
+        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._player_direction is None:
+                raise SerializationError("player_direction must be provided.")
+            writer.add_char(int(data._player_direction))
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_short(data._hp_percentage)
+            reached_missing_optional = data._kill_steal_protection is None
+            if not reached_missing_optional:
+                writer.add_char(int(cast(NpcKillStealProtectionState, data._kill_steal_protection)))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcReplyServerPacket":

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

@@ -93,12 +93,16 @@ class NpcSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcSpecServerPacket): The data to serialize.
         """
-        if data._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        reached_missing_optional = data._experience is None
-        if not reached_missing_optional:
-            writer.add_int(cast(int, data._experience))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            reached_missing_optional = data._experience is None
+            if not reached_missing_optional:
+                writer.add_int(cast(int, data._experience))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcSpecServerPacket":

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

@@ -120,24 +120,28 @@ class NpcUpdateAttack:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcUpdateAttack): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_char(data._npc_index)
-        if data._killed is None:
-            raise SerializationError("killed must be provided.")
-        writer.add_char(int(data._killed))
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_char(data._npc_index)
+            if data._killed is None:
+                raise SerializationError("killed must be provided.")
+            writer.add_char(int(data._killed))
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcUpdateAttack":

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

@@ -68,17 +68,21 @@ class NpcUpdateChat:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcUpdateChat): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_char(data._npc_index)
-        if data._message_length is None:
-            raise SerializationError("message_length must be provided.")
-        writer.add_char(data._message_length)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        if len(data._message) > 252:
-            raise SerializationError(f"Expected length of message to be 252 or less, got {len(data._message)}.")
-        writer.add_fixed_string(data._message, data._message_length, False)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_char(data._npc_index)
+            if data._message_length is None:
+                raise SerializationError("message_length must be provided.")
+            writer.add_char(data._message_length)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            if len(data._message) > 252:
+                raise SerializationError(f"Expected length of message to be 252 or less, got {len(data._message)}.")
+            writer.add_fixed_string(data._message, data._message_length, False)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcUpdateChat":

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

@@ -69,15 +69,19 @@ class NpcUpdatePosition:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcUpdatePosition): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_char(data._npc_index)
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_char(data._npc_index)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcUpdatePosition":

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

@@ -103,26 +103,32 @@ class OnlinePlayer:
             writer (EoWriter): The writer that the data will be serialized to.
             data (OnlinePlayer): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
-        writer.add_byte(0xFF)
-        if data._title is None:
-            raise SerializationError("title must be provided.")
-        writer.add_string(data._title)
-        writer.add_byte(0xFF)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
-        if data._class_id is None:
-            raise SerializationError("class_id must be provided.")
-        writer.add_char(data._class_id)
-        if data._guild_tag is None:
-            raise SerializationError("guild_tag must be provided.")
-        writer.add_string(data._guild_tag)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.add_byte(0xFF)
+            if data._title is None:
+                raise SerializationError("title must be provided.")
+            writer.add_string(data._title)
+            writer.add_byte(0xFF)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            if data._class_id is None:
+                raise SerializationError("class_id must be provided.")
+            writer.add_char(data._class_id)
+            if data._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            writer.add_string(data._guild_tag)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "OnlinePlayer":

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

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

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

@@ -30,7 +30,7 @@ class PaperdollPingServerPacket(Packet):
     @property
     def class_id(self) -> int:
         """
-        The player's current class ID (not the item's required class ID)
+        The player's current class ID (not the item's required class ID)
 
         Note:
           - Value range is 0-252.
@@ -40,7 +40,7 @@ class PaperdollPingServerPacket(Packet):
     @class_id.setter
     def class_id(self, class_id: int) -> None:
         """
-        The player's current class ID (not the item's required class ID)
+        The player's current class ID (not the item's required class ID)
 
         Note:
           - Value range is 0-252.
@@ -85,9 +85,13 @@ class PaperdollPingServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollPingServerPacket): The data to serialize.
         """
-        if data._class_id is None:
-            raise SerializationError("class_id must be provided.")
-        writer.add_char(data._class_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._class_id is None:
+                raise SerializationError("class_id must be provided.")
+            writer.add_char(data._class_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollPingServerPacket":