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

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

@@ -58,12 +58,16 @@ class DialogQuestEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (DialogQuestEntry): The data to serialize.
         """
-        if data._quest_id is None:
-            raise SerializationError("quest_id must be provided.")
-        writer.add_short(data._quest_id)
-        if data._quest_name is None:
-            raise SerializationError("quest_name must be provided.")
-        writer.add_string(data._quest_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._quest_id is None:
+                raise SerializationError("quest_id must be provided.")
+            writer.add_short(data._quest_id)
+            if data._quest_name is None:
+                raise SerializationError("quest_name must be provided.")
+            writer.add_string(data._quest_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DialogQuestEntry":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class DoorCloseServerPacket(Packet):
+    """
+    Reply to trying to open a locked door
+    """
     _byte_size: int = 0
     _key: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class DoorCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (DoorCloseServerPacket): The data to serialize.
         """
-        if data._key is None:
-            raise SerializationError("key must be provided.")
-        writer.add_char(data._key)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._key is None:
+                raise SerializationError("key must be provided.")
+            writer.add_char(data._key)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DoorCloseServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class DoorOpenServerPacket(Packet):
+    """
+    Nearby door opening
+    """
     _byte_size: int = 0
     _coords: Coords = None # type: ignore [assignment]
 
@@ -71,10 +74,14 @@ class DoorOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (DoorOpenServerPacket): The data to serialize.
         """
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        writer.add_char(0)
+        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)
+            writer.add_char(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "DoorOpenServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class EffectAdminServerPacket(Packet):
+    """
+    Nearby character taking spike damage
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _hp_percentage: int = None # type: ignore [assignment]
@@ -121,18 +124,22 @@ class EffectAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectAdminServerPacket): 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)
-        if data._died is None:
-            raise SerializationError("died must be provided.")
-        writer.add_char(1 if data._died else 0)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._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)
+            if data._died is None:
+                raise SerializationError("died must be provided.")
+            writer.add_char(1 if data._died else 0)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectAdminServerPacket":

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

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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class EffectPlayerServerPacket(Packet):
+    """
+    Nearby player doing an effect
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _effect_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class EffectPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectPlayerServerPacket): 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._effect_id is None:
-            raise SerializationError("effect_id must be provided.")
-        writer.add_three(data._effect_id)
+        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._effect_id is None:
+                raise SerializationError("effect_id must be provided.")
+            writer.add_three(data._effect_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectPlayerServerPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class EffectReportServerPacket(Packet):
+    """
+    Map spike timer
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class EffectReportServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectReportServerPacket): 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_string("S")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectReportServerPacket":
@@ -79,8 +84,7 @@ class EffectReportServerPacket(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_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class EffectSpecServerPacket(Packet):
+    """
+    Taking spike or tp drain damage
+    """
     _byte_size: int = 0
     _map_damage_type: MapDamageType = None # type: ignore [assignment]
     _map_damage_type_data: 'EffectSpecServerPacket.MapDamageTypeData' = None
@@ -84,17 +87,21 @@ class EffectSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectSpecServerPacket): The data to serialize.
         """
-        if data._map_damage_type is None:
-            raise SerializationError("map_damage_type must be provided.")
-        writer.add_char(int(data._map_damage_type))
-        if data._map_damage_type == MapDamageType.TpDrain:
-            if not isinstance(data._map_damage_type_data, EffectSpecServerPacket.MapDamageTypeDataTpDrain):
-                raise SerializationError("Expected map_damage_type_data to be type EffectSpecServerPacket.MapDamageTypeDataTpDrain for map_damage_type " + MapDamageType(data._map_damage_type).name + ".")
-            EffectSpecServerPacket.MapDamageTypeDataTpDrain.serialize(writer, data._map_damage_type_data)
-        elif data._map_damage_type == MapDamageType.Spikes:
-            if not isinstance(data._map_damage_type_data, EffectSpecServerPacket.MapDamageTypeDataSpikes):
-                raise SerializationError("Expected map_damage_type_data to be type EffectSpecServerPacket.MapDamageTypeDataSpikes for map_damage_type " + MapDamageType(data._map_damage_type).name + ".")
-            EffectSpecServerPacket.MapDamageTypeDataSpikes.serialize(writer, data._map_damage_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._map_damage_type is None:
+                raise SerializationError("map_damage_type must be provided.")
+            writer.add_char(int(data._map_damage_type))
+            if data._map_damage_type == MapDamageType.TpDrain:
+                if not isinstance(data._map_damage_type_data, EffectSpecServerPacket.MapDamageTypeDataTpDrain):
+                    raise SerializationError("Expected map_damage_type_data to be type EffectSpecServerPacket.MapDamageTypeDataTpDrain for map_damage_type " + MapDamageType(data._map_damage_type).name + ".")
+                EffectSpecServerPacket.MapDamageTypeDataTpDrain.serialize(writer, data._map_damage_type_data)
+            elif data._map_damage_type == MapDamageType.Spikes:
+                if not isinstance(data._map_damage_type_data, EffectSpecServerPacket.MapDamageTypeDataSpikes):
+                    raise SerializationError("Expected map_damage_type_data to be type EffectSpecServerPacket.MapDamageTypeDataSpikes for map_damage_type " + MapDamageType(data._map_damage_type).name + ".")
+                EffectSpecServerPacket.MapDamageTypeDataSpikes.serialize(writer, data._map_damage_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectSpecServerPacket":
@@ -125,10 +132,9 @@ class EffectSpecServerPacket(Packet):
         return f"EffectSpecServerPacket(byte_size={repr(self._byte_size)}, map_damage_type={repr(self._map_damage_type)}, map_damage_type_data={repr(self._map_damage_type_data)})"
 
     MapDamageTypeData = Union['EffectSpecServerPacket.MapDamageTypeDataTpDrain', 'EffectSpecServerPacket.MapDamageTypeDataSpikes', None]
-    MapDamageTypeData.__doc__ = \
-        """
-        Data associated with different values of the `map_damage_type` field.
-        """
+    """
+    Data associated with different values of the `map_damage_type` field.
+    """
 
     class MapDamageTypeDataTpDrain:
         """
@@ -206,15 +212,19 @@ class EffectSpecServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (EffectSpecServerPacket.MapDamageTypeDataTpDrain): The data to serialize.
             """
-            if data._tp_damage is None:
-                raise SerializationError("tp_damage must be provided.")
-            writer.add_short(data._tp_damage)
-            if data._tp is None:
-                raise SerializationError("tp must be provided.")
-            writer.add_short(data._tp)
-            if data._max_tp is None:
-                raise SerializationError("max_tp must be provided.")
-            writer.add_short(data._max_tp)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._tp_damage is None:
+                    raise SerializationError("tp_damage must be provided.")
+                writer.add_short(data._tp_damage)
+                if data._tp is None:
+                    raise SerializationError("tp must be provided.")
+                writer.add_short(data._tp)
+                if data._max_tp is None:
+                    raise SerializationError("max_tp must be provided.")
+                writer.add_short(data._max_tp)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "EffectSpecServerPacket.MapDamageTypeDataTpDrain":
@@ -318,15 +328,19 @@ class EffectSpecServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (EffectSpecServerPacket.MapDamageTypeDataSpikes): The data to serialize.
             """
-            if data._hp_damage is None:
-                raise SerializationError("hp_damage must be provided.")
-            writer.add_short(data._hp_damage)
-            if data._hp is None:
-                raise SerializationError("hp must be provided.")
-            writer.add_short(data._hp)
-            if data._max_hp is None:
-                raise SerializationError("max_hp must be provided.")
-            writer.add_short(data._max_hp)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hp_damage is None:
+                    raise SerializationError("hp_damage must be provided.")
+                writer.add_short(data._hp_damage)
+                if data._hp is None:
+                    raise SerializationError("hp must be provided.")
+                writer.add_short(data._hp)
+                if data._max_hp is None:
+                    raise SerializationError("max_hp must be provided.")
+                writer.add_short(data._max_hp)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "EffectSpecServerPacket.MapDamageTypeDataSpikes":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class EffectTargetOtherServerPacket(Packet):
+    """
+    Map drain damage
+    """
     _byte_size: int = 0
     _damage: int = None # type: ignore [assignment]
     _hp: int = None # type: ignore [assignment]
@@ -123,19 +126,23 @@ class EffectTargetOtherServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectTargetOtherServerPacket): The data to serialize.
         """
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_short(data._damage)
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._others is None:
-            raise SerializationError("others must be provided.")
-        for i in range(len(data._others)):
-            MapDrainDamageOther.serialize(writer, data._others[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_short(data._damage)
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._others is None:
+                raise SerializationError("others must be provided.")
+            for i in range(len(data._others)):
+                MapDrainDamageOther.serialize(writer, data._others[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectTargetOtherServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class EffectUseServerPacket(Packet):
+    """
+    Map effect
+    """
     _byte_size: int = 0
     _effect: MapEffect = None # type: ignore [assignment]
     _effect_data: 'EffectUseServerPacket.EffectData' = None
@@ -84,13 +87,17 @@ class EffectUseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (EffectUseServerPacket): The data to serialize.
         """
-        if data._effect is None:
-            raise SerializationError("effect must be provided.")
-        writer.add_char(int(data._effect))
-        if data._effect == MapEffect.Quake:
-            if not isinstance(data._effect_data, EffectUseServerPacket.EffectDataQuake):
-                raise SerializationError("Expected effect_data to be type EffectUseServerPacket.EffectDataQuake for effect " + MapEffect(data._effect).name + ".")
-            EffectUseServerPacket.EffectDataQuake.serialize(writer, data._effect_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._effect is None:
+                raise SerializationError("effect must be provided.")
+            writer.add_char(int(data._effect))
+            if data._effect == MapEffect.Quake:
+                if not isinstance(data._effect_data, EffectUseServerPacket.EffectDataQuake):
+                    raise SerializationError("Expected effect_data to be type EffectUseServerPacket.EffectDataQuake for effect " + MapEffect(data._effect).name + ".")
+                EffectUseServerPacket.EffectDataQuake.serialize(writer, data._effect_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EffectUseServerPacket":
@@ -119,10 +126,9 @@ class EffectUseServerPacket(Packet):
         return f"EffectUseServerPacket(byte_size={repr(self._byte_size)}, effect={repr(self._effect)}, effect_data={repr(self._effect_data)})"
 
     EffectData = Union['EffectUseServerPacket.EffectDataQuake', None]
-    EffectData.__doc__ = \
-        """
-        Data associated with different values of the `effect` field.
-        """
+    """
+    Data associated with different values of the `effect` field.
+    """
 
     class EffectDataQuake:
         """
@@ -166,9 +172,13 @@ class EffectUseServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (EffectUseServerPacket.EffectDataQuake): The data to serialize.
             """
-            if data._quake_strength is None:
-                raise SerializationError("quake_strength must be provided.")
-            writer.add_char(data._quake_strength)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._quake_strength is None:
+                    raise SerializationError("quake_strength must be provided.")
+                writer.add_char(data._quake_strength)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "EffectUseServerPacket.EffectDataQuake":

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

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

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

@@ -10,7 +10,7 @@ from .....data.eo_reader import EoReader
 class EquipmentChange:
     """
     Player equipment data.
-    Sent when a player's visible equipment changes.
+    Sent when a player's visible equipment changes.
     Note that these values are graphic IDs.
     """
     _byte_size: int = 0
@@ -119,21 +119,25 @@ class EquipmentChange:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EquipmentChange): The data to serialize.
         """
-        if data._boots is None:
-            raise SerializationError("boots must be provided.")
-        writer.add_short(data._boots)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._hat is None:
-            raise SerializationError("hat must be provided.")
-        writer.add_short(data._hat)
-        if data._weapon is None:
-            raise SerializationError("weapon must be provided.")
-        writer.add_short(data._weapon)
-        if data._shield is None:
-            raise SerializationError("shield must be provided.")
-        writer.add_short(data._shield)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._boots is None:
+                raise SerializationError("boots must be provided.")
+            writer.add_short(data._boots)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._hat is None:
+                raise SerializationError("hat must be provided.")
+            writer.add_short(data._hat)
+            if data._weapon is None:
+                raise SerializationError("weapon must be provided.")
+            writer.add_short(data._weapon)
+            if data._shield is None:
+                raise SerializationError("shield must be provided.")
+            writer.add_short(data._shield)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EquipmentChange":

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

@@ -119,21 +119,25 @@ class EquipmentCharacterSelect:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EquipmentCharacterSelect): The data to serialize.
         """
-        if data._boots is None:
-            raise SerializationError("boots must be provided.")
-        writer.add_short(data._boots)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._hat is None:
-            raise SerializationError("hat must be provided.")
-        writer.add_short(data._hat)
-        if data._shield is None:
-            raise SerializationError("shield must be provided.")
-        writer.add_short(data._shield)
-        if data._weapon is None:
-            raise SerializationError("weapon must be provided.")
-        writer.add_short(data._weapon)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._boots is None:
+                raise SerializationError("boots must be provided.")
+            writer.add_short(data._boots)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._hat is None:
+                raise SerializationError("hat must be provided.")
+            writer.add_short(data._hat)
+            if data._shield is None:
+                raise SerializationError("shield must be provided.")
+            writer.add_short(data._shield)
+            if data._weapon is None:
+                raise SerializationError("weapon must be provided.")
+            writer.add_short(data._weapon)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EquipmentCharacterSelect":

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

@@ -119,25 +119,29 @@ class EquipmentMapInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EquipmentMapInfo): The data to serialize.
         """
-        if data._boots is None:
-            raise SerializationError("boots must be provided.")
-        writer.add_short(data._boots)
-        writer.add_short(0)
-        writer.add_short(0)
-        writer.add_short(0)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        writer.add_short(0)
-        if data._hat is None:
-            raise SerializationError("hat must be provided.")
-        writer.add_short(data._hat)
-        if data._shield is None:
-            raise SerializationError("shield must be provided.")
-        writer.add_short(data._shield)
-        if data._weapon is None:
-            raise SerializationError("weapon must be provided.")
-        writer.add_short(data._weapon)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._boots is None:
+                raise SerializationError("boots must be provided.")
+            writer.add_short(data._boots)
+            writer.add_short(0)
+            writer.add_short(0)
+            writer.add_short(0)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            writer.add_short(0)
+            if data._hat is None:
+                raise SerializationError("hat must be provided.")
+            writer.add_short(data._hat)
+            if data._shield is None:
+                raise SerializationError("shield must be provided.")
+            writer.add_short(data._shield)
+            if data._weapon is None:
+                raise SerializationError("weapon must be provided.")
+            writer.add_short(data._weapon)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EquipmentMapInfo":