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

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

@@ -12,7 +12,7 @@ from .....data.eo_reader import EoReader
 
 class AvatarChange:
     """
-    Information about a nearby player's appearance changing
+    Information about a nearby player's appearance changing
     """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
@@ -82,27 +82,31 @@ class AvatarChange:
             writer (EoWriter): The writer that the data will be serialized to.
             data (AvatarChange): 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._change_type is None:
-            raise SerializationError("change_type must be provided.")
-        writer.add_char(int(data._change_type))
-        if data._sound is None:
-            raise SerializationError("sound must be provided.")
-        writer.add_char(1 if data._sound else 0)
-        if data._change_type == AvatarChangeType.Equipment:
-            if not isinstance(data._change_type_data, AvatarChange.ChangeTypeDataEquipment):
-                raise SerializationError("Expected change_type_data to be type AvatarChange.ChangeTypeDataEquipment for change_type " + AvatarChangeType(data._change_type).name + ".")
-            AvatarChange.ChangeTypeDataEquipment.serialize(writer, data._change_type_data)
-        elif data._change_type == AvatarChangeType.Hair:
-            if not isinstance(data._change_type_data, AvatarChange.ChangeTypeDataHair):
-                raise SerializationError("Expected change_type_data to be type AvatarChange.ChangeTypeDataHair for change_type " + AvatarChangeType(data._change_type).name + ".")
-            AvatarChange.ChangeTypeDataHair.serialize(writer, data._change_type_data)
-        elif data._change_type == AvatarChangeType.HairColor:
-            if not isinstance(data._change_type_data, AvatarChange.ChangeTypeDataHairColor):
-                raise SerializationError("Expected change_type_data to be type AvatarChange.ChangeTypeDataHairColor for change_type " + AvatarChangeType(data._change_type).name + ".")
-            AvatarChange.ChangeTypeDataHairColor.serialize(writer, data._change_type_data)
+        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._change_type is None:
+                raise SerializationError("change_type must be provided.")
+            writer.add_char(int(data._change_type))
+            if data._sound is None:
+                raise SerializationError("sound must be provided.")
+            writer.add_char(1 if data._sound else 0)
+            if data._change_type == AvatarChangeType.Equipment:
+                if not isinstance(data._change_type_data, AvatarChange.ChangeTypeDataEquipment):
+                    raise SerializationError("Expected change_type_data to be type AvatarChange.ChangeTypeDataEquipment for change_type " + AvatarChangeType(data._change_type).name + ".")
+                AvatarChange.ChangeTypeDataEquipment.serialize(writer, data._change_type_data)
+            elif data._change_type == AvatarChangeType.Hair:
+                if not isinstance(data._change_type_data, AvatarChange.ChangeTypeDataHair):
+                    raise SerializationError("Expected change_type_data to be type AvatarChange.ChangeTypeDataHair for change_type " + AvatarChangeType(data._change_type).name + ".")
+                AvatarChange.ChangeTypeDataHair.serialize(writer, data._change_type_data)
+            elif data._change_type == AvatarChangeType.HairColor:
+                if not isinstance(data._change_type_data, AvatarChange.ChangeTypeDataHairColor):
+                    raise SerializationError("Expected change_type_data to be type AvatarChange.ChangeTypeDataHairColor for change_type " + AvatarChangeType(data._change_type).name + ".")
+                AvatarChange.ChangeTypeDataHairColor.serialize(writer, data._change_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AvatarChange":
@@ -137,10 +141,9 @@ class AvatarChange:
         return f"AvatarChange(byte_size={repr(self._byte_size)}, player_id={repr(self._player_id)}, change_type={repr(self._change_type)}, sound={repr(self._sound)}, change_type_data={repr(self._change_type_data)})"
 
     ChangeTypeData = Union['AvatarChange.ChangeTypeDataEquipment', 'AvatarChange.ChangeTypeDataHair', 'AvatarChange.ChangeTypeDataHairColor', None]
-    ChangeTypeData.__doc__ = \
-        """
-        Data associated with different values of the `change_type` field.
-        """
+    """
+    Data associated with different values of the `change_type` field.
+    """
 
     class ChangeTypeDataEquipment:
         """
@@ -176,9 +179,13 @@ class AvatarChange:
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AvatarChange.ChangeTypeDataEquipment): The data to serialize.
             """
-            if data._equipment is None:
-                raise SerializationError("equipment must be provided.")
-            EquipmentChange.serialize(writer, data._equipment)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._equipment is None:
+                    raise SerializationError("equipment must be provided.")
+                EquipmentChange.serialize(writer, data._equipment)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AvatarChange.ChangeTypeDataEquipment":
@@ -263,12 +270,16 @@ class AvatarChange:
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AvatarChange.ChangeTypeDataHair): The data to serialize.
             """
-            if data._hair_style is None:
-                raise SerializationError("hair_style must be provided.")
-            writer.add_char(data._hair_style)
-            if data._hair_color is None:
-                raise SerializationError("hair_color must be provided.")
-            writer.add_char(data._hair_color)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hair_style is None:
+                    raise SerializationError("hair_style must be provided.")
+                writer.add_char(data._hair_style)
+                if data._hair_color is None:
+                    raise SerializationError("hair_color must be provided.")
+                writer.add_char(data._hair_color)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AvatarChange.ChangeTypeDataHair":
@@ -337,9 +348,13 @@ class AvatarChange:
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (AvatarChange.ChangeTypeDataHairColor): The data to serialize.
             """
-            if data._hair_color is None:
-                raise SerializationError("hair_color must be provided.")
-            writer.add_char(data._hair_color)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hair_color is None:
+                    raise SerializationError("hair_color must be provided.")
+                writer.add_char(data._hair_color)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "AvatarChange.ChangeTypeDataHairColor":

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

@@ -8,7 +8,7 @@ from ....protocol_enum_meta import ProtocolEnumMeta
 
 class AvatarChangeType(IntEnum, metaclass=ProtocolEnumMeta):
     """
-    How a player's appearance is changing
+    How a player's appearance is changing
     """
     Equipment = 1
     Hair = 2

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

@@ -93,12 +93,16 @@ class AvatarRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AvatarRemoveServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        reached_missing_optional = data._warp_effect is None
-        if not reached_missing_optional:
-            writer.add_char(int(cast(WarpEffect, data._warp_effect)))
+        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)
+            reached_missing_optional = data._warp_effect is None
+            if not reached_missing_optional:
+                writer.add_char(int(cast(WarpEffect, data._warp_effect)))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AvatarRemoveServerPacket":

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

@@ -151,24 +151,28 @@ class AvatarReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AvatarReplyServerPacket): 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._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._dead is None:
-            raise SerializationError("dead must be provided.")
-        writer.add_char(1 if data._dead else 0)
+        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._victim_id is None:
+                raise SerializationError("victim_id must be provided.")
+            writer.add_short(data._victim_id)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._dead is None:
+                raise SerializationError("dead must be provided.")
+            writer.add_char(1 if data._dead else 0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AvatarReplyServerPacket":

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

@@ -115,15 +115,19 @@ class BankOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BankOpenServerPacket): The data to serialize.
         """
-        if data._gold_bank is None:
-            raise SerializationError("gold_bank must be provided.")
-        writer.add_int(data._gold_bank)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_three(data._session_id)
-        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_bank is None:
+                raise SerializationError("gold_bank must be provided.")
+            writer.add_int(data._gold_bank)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_three(data._session_id)
+            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) -> "BankOpenServerPacket":

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

@@ -98,12 +98,16 @@ class BankReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BankReplyServerPacket): The data to serialize.
         """
-        if data._gold_inventory is None:
-            raise SerializationError("gold_inventory must be provided.")
-        writer.add_int(data._gold_inventory)
-        if data._gold_bank is None:
-            raise SerializationError("gold_bank must be provided.")
-        writer.add_int(data._gold_bank)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._gold_inventory is None:
+                raise SerializationError("gold_inventory must be provided.")
+            writer.add_int(data._gold_inventory)
+            if data._gold_bank is None:
+                raise SerializationError("gold_bank must be provided.")
+            writer.add_int(data._gold_bank)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BankReplyServerPacket":

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

@@ -91,12 +91,16 @@ class BarberAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BarberAgreeServerPacket): 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._change is None:
-            raise SerializationError("change must be provided.")
-        AvatarChange.serialize(writer, data._change)
+        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._change is None:
+                raise SerializationError("change must be provided.")
+            AvatarChange.serialize(writer, data._change)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BarberAgreeServerPacket":

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

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

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

@@ -66,12 +66,16 @@ class BigCoords:
             writer (EoWriter): The writer that the data will be serialized to.
             data (BigCoords): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_short(data._x)
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_short(data._y)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._x is None:
+                raise SerializationError("x must be provided.")
+            writer.add_short(data._x)
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_short(data._y)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BigCoords":

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

@@ -102,20 +102,25 @@ class BoardOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardOpenServerPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_char(data._board_id)
-        if data._posts_count is None:
-            raise SerializationError("posts_count must be provided.")
-        writer.add_char(data._posts_count)
-        if data._posts is None:
-            raise SerializationError("posts must be provided.")
-        if len(data._posts) > 252:
-            raise SerializationError(f"Expected length of posts to be 252 or less, got {len(data._posts)}.")
-        for i in range(data._posts_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_char(data._board_id)
+            if data._posts_count is None:
+                raise SerializationError("posts_count must be provided.")
+            writer.add_char(data._posts_count)
+            if data._posts is None:
+                raise SerializationError("posts must be provided.")
+            if len(data._posts) > 252:
+                raise SerializationError(f"Expected length of posts to be 252 or less, got {len(data._posts)}.")
+            for i in range(data._posts_count):
+                BoardPostListing.serialize(writer, data._posts[i])
                 writer.add_byte(0xFF)
-            BoardPostListing.serialize(writer, data._posts[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardOpenServerPacket":
@@ -138,8 +143,7 @@ class BoardOpenServerPacket(Packet):
             data._posts = []
             for i in range(data._posts_count):
                 data._posts.append(BoardPostListing.deserialize(reader))
-                if i + 1 < data._posts_count:
-                    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/board_player_server_packet.py

@@ -90,12 +90,18 @@ class BoardPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardPlayerServerPacket): The data to serialize.
         """
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
-        if data._post_body is None:
-            raise SerializationError("post_body must be provided.")
-        writer.add_string(data._post_body)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+            if data._post_body is None:
+                raise SerializationError("post_body must be provided.")
+            writer.add_string(data._post_body)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardPlayerServerPacket":

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

@@ -67,17 +67,23 @@ class BoardPostListing:
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardPostListing): The data to serialize.
         """
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
-        writer.add_byte(0xFF)
-        if data._author is None:
-            raise SerializationError("author must be provided.")
-        writer.add_string(data._author)
-        writer.add_byte(0xFF)
-        if data._subject is None:
-            raise SerializationError("subject must be provided.")
-        writer.add_string(data._subject)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+            writer.add_byte(0xFF)
+            if data._author is None:
+                raise SerializationError("author must be provided.")
+            writer.add_string(data._author)
+            writer.add_byte(0xFF)
+            if data._subject is None:
+                raise SerializationError("subject must be provided.")
+            writer.add_string(data._subject)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardPostListing":

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

@@ -94,19 +94,24 @@ class BookReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BookReplyServerPacket): The data to serialize.
         """
-        if data._details is None:
-            raise SerializationError("details must be provided.")
-        CharacterDetails.serialize(writer, data._details)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
-        writer.add_byte(0xFF)
-        if data._quest_names is None:
-            raise SerializationError("quest_names must be provided.")
-        for i in range(len(data._quest_names)):
-            if i > 0:
+        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._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            writer.add_byte(0xFF)
+            if data._quest_names is None:
+                raise SerializationError("quest_names must be provided.")
+            for i in range(len(data._quest_names)):
+                writer.add_string(data._quest_names[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._quest_names[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BookReplyServerPacket":

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

@@ -135,21 +135,25 @@ class CastAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CastAcceptServerPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        if data._caster_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        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._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            if data._caster_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            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) -> "CastAcceptServerPacket":

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

@@ -188,30 +188,34 @@ class CastReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CastReplyServerPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._caster_id is None:
-            raise SerializationError("caster_id must be provided.")
-        writer.add_short(data._caster_id)
-        if data._caster_direction is None:
-            raise SerializationError("caster_direction must be provided.")
-        writer.add_char(int(data._caster_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)
-        if data._caster_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        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._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._caster_id is None:
+                raise SerializationError("caster_id must be provided.")
+            writer.add_short(data._caster_id)
+            if data._caster_direction is None:
+                raise SerializationError("caster_direction must be provided.")
+            writer.add_char(int(data._caster_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)
+            if data._caster_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            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) -> "CastReplyServerPacket":