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

eolib/__about__.py

@@ -1 +1 @@
-__version__ = "1.1.1"
+__version__ = "1.2.0"

eolib/protocol/_generated/coords.py

@@ -66,12 +66,16 @@ class Coords:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Coords): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_char(data._x)
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_char(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_char(data._x)
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_char(data._y)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Coords":

eolib/protocol/_generated/emote.py

@@ -8,7 +8,7 @@ from ..protocol_enum_meta import ProtocolEnumMeta
 
 class Emote(IntEnum, metaclass=ProtocolEnumMeta):
     """
-    Emote that can be played over a player's head
+    Emote that can be played over a player's head
     """
     Happy = 1
     Depressed = 2

eolib/protocol/_generated/map/emf.py

@@ -380,115 +380,119 @@ class Emf:
             writer (EoWriter): The writer that the data will be serialized to.
             data (Emf): The data to serialize.
         """
-        writer.add_fixed_string("EMF", 3, False)
-        if data._rid is None:
-            raise SerializationError("rid must be provided.")
-        if len(data._rid) != 2:
-            raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
-        for i in range(2):
-            writer.add_short(data._rid[i])
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        if len(data._name) > 24:
-            raise SerializationError(f"Expected length of name to be 24 or less, got {len(data._name)}.")
-        writer.add_fixed_encoded_string(data._name, 24, True)
-        if data._type is None:
-            raise SerializationError("type must be provided.")
-        writer.add_char(int(data._type))
-        if data._timed_effect is None:
-            raise SerializationError("timed_effect must be provided.")
-        writer.add_char(int(data._timed_effect))
-        if data._music_id is None:
-            raise SerializationError("music_id must be provided.")
-        writer.add_char(data._music_id)
-        if data._music_control is None:
-            raise SerializationError("music_control must be provided.")
-        writer.add_char(int(data._music_control))
-        if data._ambient_sound_id is None:
-            raise SerializationError("ambient_sound_id must be provided.")
-        writer.add_short(data._ambient_sound_id)
-        if data._width is None:
-            raise SerializationError("width must be provided.")
-        writer.add_char(data._width)
-        if data._height is None:
-            raise SerializationError("height must be provided.")
-        writer.add_char(data._height)
-        if data._fill_tile is None:
-            raise SerializationError("fill_tile must be provided.")
-        writer.add_short(data._fill_tile)
-        if data._map_available is None:
-            raise SerializationError("map_available must be provided.")
-        writer.add_char(1 if data._map_available else 0)
-        if data._can_scroll is None:
-            raise SerializationError("can_scroll must be provided.")
-        writer.add_char(1 if data._can_scroll else 0)
-        if data._relog_x is None:
-            raise SerializationError("relog_x must be provided.")
-        writer.add_char(data._relog_x)
-        if data._relog_y is None:
-            raise SerializationError("relog_y must be provided.")
-        writer.add_char(data._relog_y)
-        writer.add_char(0)
-        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):
-            MapNpc.serialize(writer, data._npcs[i])
-        if data._legacy_door_keys_count is None:
-            raise SerializationError("legacy_door_keys_count must be provided.")
-        writer.add_char(data._legacy_door_keys_count)
-        if data._legacy_door_keys is None:
-            raise SerializationError("legacy_door_keys must be provided.")
-        if len(data._legacy_door_keys) > 252:
-            raise SerializationError(f"Expected length of legacy_door_keys to be 252 or less, got {len(data._legacy_door_keys)}.")
-        for i in range(data._legacy_door_keys_count):
-            MapLegacyDoorKey.serialize(writer, data._legacy_door_keys[i])
-        if data._items_count is None:
-            raise SerializationError("items_count must be provided.")
-        writer.add_char(data._items_count)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        if len(data._items) > 252:
-            raise SerializationError(f"Expected length of items to be 252 or less, got {len(data._items)}.")
-        for i in range(data._items_count):
-            MapItem.serialize(writer, data._items[i])
-        if data._tile_spec_rows_count is None:
-            raise SerializationError("tile_spec_rows_count must be provided.")
-        writer.add_char(data._tile_spec_rows_count)
-        if data._tile_spec_rows is None:
-            raise SerializationError("tile_spec_rows must be provided.")
-        if len(data._tile_spec_rows) > 252:
-            raise SerializationError(f"Expected length of tile_spec_rows to be 252 or less, got {len(data._tile_spec_rows)}.")
-        for i in range(data._tile_spec_rows_count):
-            MapTileSpecRow.serialize(writer, data._tile_spec_rows[i])
-        if data._warp_rows_count is None:
-            raise SerializationError("warp_rows_count must be provided.")
-        writer.add_char(data._warp_rows_count)
-        if data._warp_rows is None:
-            raise SerializationError("warp_rows must be provided.")
-        if len(data._warp_rows) > 252:
-            raise SerializationError(f"Expected length of warp_rows to be 252 or less, got {len(data._warp_rows)}.")
-        for i in range(data._warp_rows_count):
-            MapWarpRow.serialize(writer, data._warp_rows[i])
-        if data._graphic_layers is None:
-            raise SerializationError("graphic_layers must be provided.")
-        if len(data._graphic_layers) != 9:
-            raise SerializationError(f"Expected length of graphic_layers to be exactly 9, got {len(data._graphic_layers)}.")
-        for i in range(9):
-            MapGraphicLayer.serialize(writer, data._graphic_layers[i])
-        if data._signs_count is None:
-            raise SerializationError("signs_count must be provided.")
-        writer.add_char(data._signs_count)
-        if data._signs is None:
-            raise SerializationError("signs must be provided.")
-        if len(data._signs) > 252:
-            raise SerializationError(f"Expected length of signs to be 252 or less, got {len(data._signs)}.")
-        for i in range(data._signs_count):
-            MapSign.serialize(writer, data._signs[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("EMF", 3, False)
+            if data._rid is None:
+                raise SerializationError("rid must be provided.")
+            if len(data._rid) != 2:
+                raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
+            for i in range(2):
+                writer.add_short(data._rid[i])
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            if len(data._name) > 24:
+                raise SerializationError(f"Expected length of name to be 24 or less, got {len(data._name)}.")
+            writer.add_fixed_encoded_string(data._name, 24, True)
+            if data._type is None:
+                raise SerializationError("type must be provided.")
+            writer.add_char(int(data._type))
+            if data._timed_effect is None:
+                raise SerializationError("timed_effect must be provided.")
+            writer.add_char(int(data._timed_effect))
+            if data._music_id is None:
+                raise SerializationError("music_id must be provided.")
+            writer.add_char(data._music_id)
+            if data._music_control is None:
+                raise SerializationError("music_control must be provided.")
+            writer.add_char(int(data._music_control))
+            if data._ambient_sound_id is None:
+                raise SerializationError("ambient_sound_id must be provided.")
+            writer.add_short(data._ambient_sound_id)
+            if data._width is None:
+                raise SerializationError("width must be provided.")
+            writer.add_char(data._width)
+            if data._height is None:
+                raise SerializationError("height must be provided.")
+            writer.add_char(data._height)
+            if data._fill_tile is None:
+                raise SerializationError("fill_tile must be provided.")
+            writer.add_short(data._fill_tile)
+            if data._map_available is None:
+                raise SerializationError("map_available must be provided.")
+            writer.add_char(1 if data._map_available else 0)
+            if data._can_scroll is None:
+                raise SerializationError("can_scroll must be provided.")
+            writer.add_char(1 if data._can_scroll else 0)
+            if data._relog_x is None:
+                raise SerializationError("relog_x must be provided.")
+            writer.add_char(data._relog_x)
+            if data._relog_y is None:
+                raise SerializationError("relog_y must be provided.")
+            writer.add_char(data._relog_y)
+            writer.add_char(0)
+            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):
+                MapNpc.serialize(writer, data._npcs[i])
+            if data._legacy_door_keys_count is None:
+                raise SerializationError("legacy_door_keys_count must be provided.")
+            writer.add_char(data._legacy_door_keys_count)
+            if data._legacy_door_keys is None:
+                raise SerializationError("legacy_door_keys must be provided.")
+            if len(data._legacy_door_keys) > 252:
+                raise SerializationError(f"Expected length of legacy_door_keys to be 252 or less, got {len(data._legacy_door_keys)}.")
+            for i in range(data._legacy_door_keys_count):
+                MapLegacyDoorKey.serialize(writer, data._legacy_door_keys[i])
+            if data._items_count is None:
+                raise SerializationError("items_count must be provided.")
+            writer.add_char(data._items_count)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            if len(data._items) > 252:
+                raise SerializationError(f"Expected length of items to be 252 or less, got {len(data._items)}.")
+            for i in range(data._items_count):
+                MapItem.serialize(writer, data._items[i])
+            if data._tile_spec_rows_count is None:
+                raise SerializationError("tile_spec_rows_count must be provided.")
+            writer.add_char(data._tile_spec_rows_count)
+            if data._tile_spec_rows is None:
+                raise SerializationError("tile_spec_rows must be provided.")
+            if len(data._tile_spec_rows) > 252:
+                raise SerializationError(f"Expected length of tile_spec_rows to be 252 or less, got {len(data._tile_spec_rows)}.")
+            for i in range(data._tile_spec_rows_count):
+                MapTileSpecRow.serialize(writer, data._tile_spec_rows[i])
+            if data._warp_rows_count is None:
+                raise SerializationError("warp_rows_count must be provided.")
+            writer.add_char(data._warp_rows_count)
+            if data._warp_rows is None:
+                raise SerializationError("warp_rows must be provided.")
+            if len(data._warp_rows) > 252:
+                raise SerializationError(f"Expected length of warp_rows to be 252 or less, got {len(data._warp_rows)}.")
+            for i in range(data._warp_rows_count):
+                MapWarpRow.serialize(writer, data._warp_rows[i])
+            if data._graphic_layers is None:
+                raise SerializationError("graphic_layers must be provided.")
+            if len(data._graphic_layers) != 9:
+                raise SerializationError(f"Expected length of graphic_layers to be exactly 9, got {len(data._graphic_layers)}.")
+            for i in range(9):
+                MapGraphicLayer.serialize(writer, data._graphic_layers[i])
+            if data._signs_count is None:
+                raise SerializationError("signs_count must be provided.")
+            writer.add_char(data._signs_count)
+            if data._signs is None:
+                raise SerializationError("signs must be provided.")
+            if len(data._signs) > 252:
+                raise SerializationError(f"Expected length of signs to be 252 or less, got {len(data._signs)}.")
+            for i in range(data._signs_count):
+                MapSign.serialize(writer, data._signs[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "Emf":

eolib/protocol/_generated/map/map_graphic_layer.py

@@ -53,15 +53,19 @@ class MapGraphicLayer:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapGraphicLayer): The data to serialize.
         """
-        if data._graphic_rows_count is None:
-            raise SerializationError("graphic_rows_count must be provided.")
-        writer.add_char(data._graphic_rows_count)
-        if data._graphic_rows is None:
-            raise SerializationError("graphic_rows must be provided.")
-        if len(data._graphic_rows) > 252:
-            raise SerializationError(f"Expected length of graphic_rows to be 252 or less, got {len(data._graphic_rows)}.")
-        for i in range(data._graphic_rows_count):
-            MapGraphicRow.serialize(writer, data._graphic_rows[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._graphic_rows_count is None:
+                raise SerializationError("graphic_rows_count must be provided.")
+            writer.add_char(data._graphic_rows_count)
+            if data._graphic_rows is None:
+                raise SerializationError("graphic_rows must be provided.")
+            if len(data._graphic_rows) > 252:
+                raise SerializationError(f"Expected length of graphic_rows to be 252 or less, got {len(data._graphic_rows)}.")
+            for i in range(data._graphic_rows_count):
+                MapGraphicRow.serialize(writer, data._graphic_rows[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapGraphicLayer":

eolib/protocol/_generated/map/map_graphic_row.py

@@ -70,18 +70,22 @@ class MapGraphicRow:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapGraphicRow): The data to serialize.
         """
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_char(data._y)
-        if data._tiles_count is None:
-            raise SerializationError("tiles_count must be provided.")
-        writer.add_char(data._tiles_count)
-        if data._tiles is None:
-            raise SerializationError("tiles must be provided.")
-        if len(data._tiles) > 252:
-            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
-        for i in range(data._tiles_count):
-            MapGraphicRowTile.serialize(writer, data._tiles[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_char(data._y)
+            if data._tiles_count is None:
+                raise SerializationError("tiles_count must be provided.")
+            writer.add_char(data._tiles_count)
+            if data._tiles is None:
+                raise SerializationError("tiles must be provided.")
+            if len(data._tiles) > 252:
+                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
+            for i in range(data._tiles_count):
+                MapGraphicRowTile.serialize(writer, data._tiles[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapGraphicRow":

eolib/protocol/_generated/map/map_graphic_row_tile.py

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

eolib/protocol/_generated/map/map_item.py

@@ -127,24 +127,28 @@ class MapItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapItem): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._key is None:
-            raise SerializationError("key must be provided.")
-        writer.add_short(data._key)
-        if data._chest_slot is None:
-            raise SerializationError("chest_slot must be provided.")
-        writer.add_char(data._chest_slot)
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._spawn_time is None:
-            raise SerializationError("spawn_time must be provided.")
-        writer.add_short(data._spawn_time)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_three(data._amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._key is None:
+                raise SerializationError("key must be provided.")
+            writer.add_short(data._key)
+            if data._chest_slot is None:
+                raise SerializationError("chest_slot must be provided.")
+            writer.add_char(data._chest_slot)
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._spawn_time is None:
+                raise SerializationError("spawn_time must be provided.")
+            writer.add_short(data._spawn_time)
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_three(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapItem":

eolib/protocol/_generated/map/map_legacy_door_key.py

@@ -59,12 +59,16 @@ class MapLegacyDoorKey:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapLegacyDoorKey): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._key is None:
-            raise SerializationError("key must be provided.")
-        writer.add_short(data._key)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._key is None:
+                raise SerializationError("key must be provided.")
+            writer.add_short(data._key)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapLegacyDoorKey":

eolib/protocol/_generated/map/map_npc.py

@@ -110,21 +110,25 @@ class MapNpc:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapNpc): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._spawn_type is None:
-            raise SerializationError("spawn_type must be provided.")
-        writer.add_char(data._spawn_type)
-        if data._spawn_time is None:
-            raise SerializationError("spawn_time must be provided.")
-        writer.add_short(data._spawn_time)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_char(data._amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._spawn_type is None:
+                raise SerializationError("spawn_type must be provided.")
+            writer.add_char(data._spawn_type)
+            if data._spawn_time is None:
+                raise SerializationError("spawn_time must be provided.")
+            writer.add_short(data._spawn_time)
+            if data._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_char(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapNpc":

eolib/protocol/_generated/map/map_sign.py

@@ -78,20 +78,24 @@ class MapSign:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapSign): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._string_data_length is None:
-            raise SerializationError("string_data_length must be provided.")
-        writer.add_short(data._string_data_length + 1)
-        if data._string_data is None:
-            raise SerializationError("string_data must be provided.")
-        if len(data._string_data) > 64007:
-            raise SerializationError(f"Expected length of string_data to be 64007 or less, got {len(data._string_data)}.")
-        writer.add_fixed_encoded_string(data._string_data, data._string_data_length, False)
-        if data._title_length is None:
-            raise SerializationError("title_length must be provided.")
-        writer.add_char(data._title_length)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            if data._string_data_length is None:
+                raise SerializationError("string_data_length must be provided.")
+            writer.add_short(data._string_data_length + 1)
+            if data._string_data is None:
+                raise SerializationError("string_data must be provided.")
+            if len(data._string_data) > 64007:
+                raise SerializationError(f"Expected length of string_data to be 64007 or less, got {len(data._string_data)}.")
+            writer.add_fixed_encoded_string(data._string_data, data._string_data_length, False)
+            if data._title_length is None:
+                raise SerializationError("title_length must be provided.")
+            writer.add_char(data._title_length)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapSign":

eolib/protocol/_generated/map/map_tile_spec_row.py

@@ -70,18 +70,22 @@ class MapTileSpecRow:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapTileSpecRow): The data to serialize.
         """
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_char(data._y)
-        if data._tiles_count is None:
-            raise SerializationError("tiles_count must be provided.")
-        writer.add_char(data._tiles_count)
-        if data._tiles is None:
-            raise SerializationError("tiles must be provided.")
-        if len(data._tiles) > 252:
-            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
-        for i in range(data._tiles_count):
-            MapTileSpecRowTile.serialize(writer, data._tiles[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_char(data._y)
+            if data._tiles_count is None:
+                raise SerializationError("tiles_count must be provided.")
+            writer.add_char(data._tiles_count)
+            if data._tiles is None:
+                raise SerializationError("tiles must be provided.")
+            if len(data._tiles) > 252:
+                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
+            for i in range(data._tiles_count):
+                MapTileSpecRowTile.serialize(writer, data._tiles[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapTileSpecRow":

eolib/protocol/_generated/map/map_tile_spec_row_tile.py

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