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

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

@@ -144,27 +144,31 @@ class ServerSettings:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ServerSettings): The data to serialize.
         """
-        if data._jail_map is None:
-            raise SerializationError("jail_map must be provided.")
-        writer.add_short(data._jail_map)
-        if data._rescue_map is None:
-            raise SerializationError("rescue_map must be provided.")
-        writer.add_short(data._rescue_map)
-        if data._rescue_coords is None:
-            raise SerializationError("rescue_coords must be provided.")
-        Coords.serialize(writer, data._rescue_coords)
-        if data._spy_and_light_guide_flood_rate is None:
-            raise SerializationError("spy_and_light_guide_flood_rate must be provided.")
-        writer.add_short(data._spy_and_light_guide_flood_rate)
-        if data._guardian_flood_rate is None:
-            raise SerializationError("guardian_flood_rate must be provided.")
-        writer.add_short(data._guardian_flood_rate)
-        if data._game_master_flood_rate is None:
-            raise SerializationError("game_master_flood_rate must be provided.")
-        writer.add_short(data._game_master_flood_rate)
-        if data._high_game_master_flood_rate is None:
-            raise SerializationError("high_game_master_flood_rate must be provided.")
-        writer.add_short(data._high_game_master_flood_rate)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._jail_map is None:
+                raise SerializationError("jail_map must be provided.")
+            writer.add_short(data._jail_map)
+            if data._rescue_map is None:
+                raise SerializationError("rescue_map must be provided.")
+            writer.add_short(data._rescue_map)
+            if data._rescue_coords is None:
+                raise SerializationError("rescue_coords must be provided.")
+            Coords.serialize(writer, data._rescue_coords)
+            if data._spy_and_light_guide_flood_rate is None:
+                raise SerializationError("spy_and_light_guide_flood_rate must be provided.")
+            writer.add_short(data._spy_and_light_guide_flood_rate)
+            if data._guardian_flood_rate is None:
+                raise SerializationError("guardian_flood_rate must be provided.")
+            writer.add_short(data._guardian_flood_rate)
+            if data._game_master_flood_rate is None:
+                raise SerializationError("game_master_flood_rate must be provided.")
+            writer.add_short(data._game_master_flood_rate)
+            if data._high_game_master_flood_rate is None:
+                raise SerializationError("high_game_master_flood_rate must be provided.")
+            writer.add_short(data._high_game_master_flood_rate)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ServerSettings":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ShopBuyServerPacket(Packet):
+    """
+    Response to purchasing an item from a shop
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
     _bought_item: Item = None # type: ignore [assignment]
@@ -98,15 +101,19 @@ class ShopBuyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopBuyServerPacket): 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._bought_item is None:
-            raise SerializationError("bought_item must be provided.")
-        Item.serialize(writer, data._bought_item)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        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._bought_item is None:
+                raise SerializationError("bought_item must be provided.")
+            Item.serialize(writer, data._bought_item)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopBuyServerPacket":

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

@@ -68,15 +68,19 @@ class ShopCraftItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCraftItem): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._ingredients is None:
-            raise SerializationError("ingredients must be provided.")
-        if len(data._ingredients) != 4:
-            raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
-        for i in range(4):
-            CharItem.serialize(writer, data._ingredients[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._ingredients is None:
+                raise SerializationError("ingredients must be provided.")
+            if len(data._ingredients) != 4:
+                raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
+            for i in range(4):
+                CharItem.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCraftItem":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ShopCreateServerPacket(Packet):
+    """
+    Response to crafting an item from a shop
+    """
     _byte_size: int = 0
     _craft_item_id: int = None # type: ignore [assignment]
     _weight: Weight = None # type: ignore [assignment]
@@ -107,18 +110,22 @@ class ShopCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCreateServerPacket): The data to serialize.
         """
-        if data._craft_item_id is None:
-            raise SerializationError("craft_item_id must be provided.")
-        writer.add_short(data._craft_item_id)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._ingredients is None:
-            raise SerializationError("ingredients must be provided.")
-        if len(data._ingredients) != 4:
-            raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
-        for i in range(4):
-            Item.serialize(writer, data._ingredients[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._craft_item_id is None:
+                raise SerializationError("craft_item_id must be provided.")
+            writer.add_short(data._craft_item_id)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._ingredients is None:
+                raise SerializationError("ingredients must be provided.")
+            if len(data._ingredients) != 4:
+                raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
+            for i in range(4):
+                Item.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCreateServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ShopOpenServerPacket(Packet):
+    """
+    Response from talking to a shop NPC
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _shop_name: str = None # type: ignore [assignment]
@@ -108,23 +111,29 @@ class ShopOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._shop_name is None:
-            raise SerializationError("shop_name must be provided.")
-        writer.add_string(data._shop_name)
-        writer.add_byte(0xFF)
-        if data._trade_items is None:
-            raise SerializationError("trade_items must be provided.")
-        for i in range(len(data._trade_items)):
-            ShopTradeItem.serialize(writer, data._trade_items[i])
-        writer.add_byte(0xFF)
-        if data._craft_items is None:
-            raise SerializationError("craft_items must be provided.")
-        for i in range(len(data._craft_items)):
-            ShopCraftItem.serialize(writer, data._craft_items[i])
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._shop_name is None:
+                raise SerializationError("shop_name must be provided.")
+            writer.add_string(data._shop_name)
+            writer.add_byte(0xFF)
+            if data._trade_items is None:
+                raise SerializationError("trade_items must be provided.")
+            for i in range(len(data._trade_items)):
+                ShopTradeItem.serialize(writer, data._trade_items[i])
+            writer.add_byte(0xFF)
+            if data._craft_items is None:
+                raise SerializationError("craft_items must be provided.")
+            for i in range(len(data._craft_items)):
+                ShopCraftItem.serialize(writer, data._craft_items[i])
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopOpenServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ShopSellServerPacket(Packet):
+    """
+    Response to selling an item to a shop
+    """
     _byte_size: int = 0
     _sold_item: ShopSoldItem = None # type: ignore [assignment]
     _gold_amount: int = None # type: ignore [assignment]
@@ -98,15 +101,19 @@ class ShopSellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopSellServerPacket): The data to serialize.
         """
-        if data._sold_item is None:
-            raise SerializationError("sold_item must be provided.")
-        ShopSoldItem.serialize(writer, data._sold_item)
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sold_item is None:
+                raise SerializationError("sold_item must be provided.")
+            ShopSoldItem.serialize(writer, data._sold_item)
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopSellServerPacket":

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

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

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

@@ -100,18 +100,22 @@ class ShopTradeItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopTradeItem): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._buy_price is None:
-            raise SerializationError("buy_price must be provided.")
-        writer.add_three(data._buy_price)
-        if data._sell_price is None:
-            raise SerializationError("sell_price must be provided.")
-        writer.add_three(data._sell_price)
-        if data._max_buy_amount is None:
-            raise SerializationError("max_buy_amount must be provided.")
-        writer.add_char(data._max_buy_amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._buy_price is None:
+                raise SerializationError("buy_price must be provided.")
+            writer.add_three(data._buy_price)
+            if data._sell_price is None:
+                raise SerializationError("sell_price must be provided.")
+            writer.add_three(data._sell_price)
+            if data._max_buy_amount is None:
+                raise SerializationError("max_buy_amount must be provided.")
+            writer.add_char(data._max_buy_amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopTradeItem":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SitCloseServerPacket(Packet):
+    """
+    Your character standing up
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class SitCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitCloseServerPacket): 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._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        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._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitCloseServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SitPlayerServerPacket(Packet):
+    """
+    Nearby player sitting down
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -98,16 +101,20 @@ class SitPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitPlayerServerPacket): 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._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))
-        writer.add_char(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._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))
+            writer.add_char(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitPlayerServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SitRemoveServerPacket(Packet):
+    """
+    Nearby player standing up
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class SitRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitRemoveServerPacket): 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._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        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._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitRemoveServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SitReplyServerPacket(Packet):
+    """
+    Your character sitting down
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -98,16 +101,20 @@ class SitReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitReplyServerPacket): 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._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))
-        writer.add_char(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._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))
+            writer.add_char(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitReplyServerPacket":

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

@@ -130,27 +130,31 @@ class SkillLearn:
             writer (EoWriter): The writer that the data will be serialized to.
             data (SkillLearn): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._level_requirement is None:
-            raise SerializationError("level_requirement must be provided.")
-        writer.add_char(data._level_requirement)
-        if data._class_requirement is None:
-            raise SerializationError("class_requirement must be provided.")
-        writer.add_char(data._class_requirement)
-        if data._cost is None:
-            raise SerializationError("cost must be provided.")
-        writer.add_int(data._cost)
-        if data._skill_requirements is None:
-            raise SerializationError("skill_requirements must be provided.")
-        if len(data._skill_requirements) != 4:
-            raise SerializationError(f"Expected length of skill_requirements to be exactly 4, got {len(data._skill_requirements)}.")
-        for i in range(4):
-            writer.add_short(data._skill_requirements[i])
-        if data._stat_requirements is None:
-            raise SerializationError("stat_requirements must be provided.")
-        CharacterBaseStats.serialize(writer, data._stat_requirements)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._level_requirement is None:
+                raise SerializationError("level_requirement must be provided.")
+            writer.add_char(data._level_requirement)
+            if data._class_requirement is None:
+                raise SerializationError("class_requirement must be provided.")
+            writer.add_char(data._class_requirement)
+            if data._cost is None:
+                raise SerializationError("cost must be provided.")
+            writer.add_int(data._cost)
+            if data._skill_requirements is None:
+                raise SerializationError("skill_requirements must be provided.")
+            if len(data._skill_requirements) != 4:
+                raise SerializationError(f"Expected length of skill_requirements to be exactly 4, got {len(data._skill_requirements)}.")
+            for i in range(4):
+                writer.add_short(data._skill_requirements[i])
+            if data._stat_requirements is None:
+                raise SerializationError("stat_requirements must be provided.")
+            CharacterBaseStats.serialize(writer, data._stat_requirements)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SkillLearn":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellErrorServerPacket(Packet):
+    """
+    Show flood protection message (vestigial)
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class SpellErrorServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellErrorServerPacket): 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) -> "SpellErrorServerPacket":
@@ -79,8 +84,7 @@ class SpellErrorServerPacket(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/spell_player_server_packet.py

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellPlayerServerPacket(Packet):
+    """
+    Nearby player raising their arm to cast a spell (vestigial)
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _direction: Direction = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class SpellPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellPlayerServerPacket): 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._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._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            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) -> "SpellPlayerServerPacket":