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

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

@@ -15,6 +15,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class NpcReplyServerPacket(Packet):
+    """
+    Nearby NPC hit by a player
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _player_direction: Direction = None # type: ignore [assignment]
@@ -151,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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class NpcSpecServerPacket(Packet):
+    """
+    Nearby NPC killed by player
+    """
     _byte_size: int = 0
     _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
     _experience: Optional[int] = None # type: ignore [assignment]
@@ -90,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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PaperdollAgreeServerPacket(Packet):
+    """
+    Reply to equipping an item
+    """
     _byte_size: int = 0
     _change: AvatarChange = None # type: ignore [assignment]
     _item_id: int = None # type: ignore [assignment]
@@ -132,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PaperdollPingServerPacket(Packet):
+    """
+    Failed to equip an item due to being the incorrect class
+    """
     _byte_size: int = 0
     _class_id: int = None # type: ignore [assignment]
 
@@ -27,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.
@@ -37,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.
@@ -82,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":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PaperdollRemoveServerPacket(Packet):
+    """
+    Reply to unequipping an item
+    """
     _byte_size: int = 0
     _change: AvatarChange = None # type: ignore [assignment]
     _item_id: int = None # type: ignore [assignment]
@@ -115,18 +118,22 @@ class PaperdollRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollRemoveServerPacket): The data to serialize.
         """
-        if data._change is None:
-            raise SerializationError("change must be provided.")
-        AvatarChange.serialize(writer, data._change)
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._sub_loc is None:
-            raise SerializationError("sub_loc must be provided.")
-        writer.add_char(data._sub_loc)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsEquipmentChange.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._change is None:
+                raise SerializationError("change must be provided.")
+            AvatarChange.serialize(writer, data._change)
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._sub_loc is None:
+                raise SerializationError("sub_loc must be provided.")
+            writer.add_char(data._sub_loc)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsEquipmentChange.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollRemoveServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PaperdollReplyServerPacket(Packet):
+    """
+    Reply to requesting a paperdoll
+    """
     _byte_size: int = 0
     _details: CharacterDetails = None # type: ignore [assignment]
     _equipment: EquipmentPaperdoll = None # type: ignore [assignment]
@@ -91,15 +94,21 @@ class PaperdollReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PaperdollReplyServerPacket): The data to serialize.
         """
-        if data._details is None:
-            raise SerializationError("details must be provided.")
-        CharacterDetails.serialize(writer, data._details)
-        if data._equipment is None:
-            raise SerializationError("equipment must be provided.")
-        EquipmentPaperdoll.serialize(writer, data._equipment)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._details is None:
+                raise SerializationError("details must be provided.")
+            CharacterDetails.serialize(writer, data._details)
+            if data._equipment is None:
+                raise SerializationError("equipment must be provided.")
+            EquipmentPaperdoll.serialize(writer, data._equipment)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PaperdollReplyServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyAddServerPacket(Packet):
+    """
+    New player joined the party
+    """
     _byte_size: int = 0
     _member: PartyMember = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class PartyAddServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyAddServerPacket): The data to serialize.
         """
-        if data._member is None:
-            raise SerializationError("member must be provided.")
-        PartyMember.serialize(writer, data._member)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._member is None:
+                raise SerializationError("member must be provided.")
+            PartyMember.serialize(writer, data._member)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyAddServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyAgreeServerPacket(Packet):
+    """
+    Party member list update
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _hp_percentage: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class PartyAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyAgreeServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyAgreeServerPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyCloseServerPacket(Packet):
+    """
+    Left / disbanded a party
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class PartyCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyCloseServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_byte(255)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyCloseServerPacket":
@@ -79,8 +84,7 @@ class PartyCloseServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_byte()
+            reader.get_byte()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PartyCreateServerPacket(Packet):
+    """
+    Member list received when party is first joined
+    """
     _byte_size: int = 0
     _members: list[PartyMember] = None # type: ignore [assignment]
 
@@ -72,12 +75,17 @@ class PartyCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PartyCreateServerPacket): The data to serialize.
         """
-        if data._members is None:
-            raise SerializationError("members must be provided.")
-        for i in range(len(data._members)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._members is None:
+                raise SerializationError("members must be provided.")
+            for i in range(len(data._members)):
+                PartyMember.serialize(writer, data._members[i])
                 writer.add_byte(0xFF)
-            PartyMember.serialize(writer, data._members[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PartyCreateServerPacket":

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

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