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

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ArenaDropServerPacket(Packet):
+    """
+    "Arena is blocked" message
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class ArenaDropServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ArenaDropServerPacket): 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("N")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ArenaDropServerPacket":
@@ -79,8 +84,7 @@ class ArenaDropServerPacket(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/arena_spec_server_packet.py

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ArenaSpecServerPacket(Packet):
+    """
+    Arena kill message
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _direction: Direction = None # type: ignore [assignment]
@@ -123,25 +126,31 @@ class ArenaSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ArenaSpecServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        writer.add_byte(0xFF)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        writer.add_byte(0xFF)
-        if data._kills_count is None:
-            raise SerializationError("kills_count must be provided.")
-        writer.add_int(data._kills_count)
-        writer.add_byte(0xFF)
-        if data._killer_name is None:
-            raise SerializationError("killer_name must be provided.")
-        writer.add_string(data._killer_name)
-        writer.add_byte(0xFF)
-        if data._victim_name is None:
-            raise SerializationError("victim_name must be provided.")
-        writer.add_string(data._victim_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            writer.add_byte(0xFF)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            writer.add_byte(0xFF)
+            if data._kills_count is None:
+                raise SerializationError("kills_count must be provided.")
+            writer.add_int(data._kills_count)
+            writer.add_byte(0xFF)
+            if data._killer_name is None:
+                raise SerializationError("killer_name must be provided.")
+            writer.add_string(data._killer_name)
+            writer.add_byte(0xFF)
+            if data._victim_name is None:
+                raise SerializationError("victim_name must be provided.")
+            writer.add_string(data._victim_name)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ArenaSpecServerPacket":

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

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

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

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AttackPlayerServerPacket(Packet):
+    """
+    Nearby player attacking
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _direction: Direction = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class AttackPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AttackPlayerServerPacket): 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) -> "AttackPlayerServerPacket":

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

@@ -12,11 +12,14 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AvatarAdminServerPacket(Packet):
+    """
+    Nearby player hit by a damage spell from a player
+    """
     _byte_size: int = 0
     _caster_id: int = None # type: ignore [assignment]
     _victim_id: int = None # type: ignore [assignment]
-    _caster_direction: Direction = None # type: ignore [assignment]
     _damage: int = None # type: ignore [assignment]
+    _caster_direction: Direction = None # type: ignore [assignment]
     _hp_percentage: int = None # type: ignore [assignment]
     _victim_died: bool = None # type: ignore [assignment]
     _spell_id: int = None # type: ignore [assignment]
@@ -63,14 +66,6 @@ class AvatarAdminServerPacket(Packet):
         """
         self._victim_id = victim_id
 
-    @property
-    def caster_direction(self) -> Direction:
-        return self._caster_direction
-
-    @caster_direction.setter
-    def caster_direction(self, caster_direction: Direction) -> None:
-        self._caster_direction = caster_direction
-
     @property
     def damage(self) -> int:
         """
@@ -87,6 +82,14 @@ class AvatarAdminServerPacket(Packet):
         """
         self._damage = damage
 
+    @property
+    def caster_direction(self) -> Direction:
+        return self._caster_direction
+
+    @caster_direction.setter
+    def caster_direction(self, caster_direction: Direction) -> None:
+        self._caster_direction = caster_direction
+
     @property
     def hp_percentage(self) -> int:
         """
@@ -165,27 +168,31 @@ class AvatarAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AvatarAdminServerPacket): The data to serialize.
         """
-        if data._caster_id is None:
-            raise SerializationError("caster_id must be provided.")
-        writer.add_short(data._caster_id)
-        if data._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._caster_direction is None:
-            raise SerializationError("caster_direction must be provided.")
-        writer.add_char(int(data._caster_direction))
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._victim_died is None:
-            raise SerializationError("victim_died must be provided.")
-        writer.add_char(1 if data._victim_died else 0)
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._caster_id is None:
+                raise SerializationError("caster_id must be provided.")
+            writer.add_short(data._caster_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._caster_direction is None:
+                raise SerializationError("caster_direction must be provided.")
+            writer.add_char(int(data._caster_direction))
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._victim_died is None:
+                raise SerializationError("victim_died must be provided.")
+            writer.add_char(1 if data._victim_died else 0)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AvatarAdminServerPacket":
@@ -204,8 +211,8 @@ class AvatarAdminServerPacket(Packet):
             reader_start_position: int = reader.position
             data._caster_id = reader.get_short()
             data._victim_id = reader.get_short()
-            data._caster_direction = Direction(reader.get_char())
             data._damage = reader.get_three()
+            data._caster_direction = Direction(reader.get_char())
             data._hp_percentage = reader.get_char()
             data._victim_died = reader.get_char() != 0
             data._spell_id = reader.get_short()
@@ -215,4 +222,4 @@ class AvatarAdminServerPacket(Packet):
             reader.chunked_reading_mode = old_chunked_reading_mode
 
     def __repr__(self):
-        return f"AvatarAdminServerPacket(byte_size={repr(self._byte_size)}, caster_id={repr(self._caster_id)}, victim_id={repr(self._victim_id)}, caster_direction={repr(self._caster_direction)}, damage={repr(self._damage)}, hp_percentage={repr(self._hp_percentage)}, victim_died={repr(self._victim_died)}, spell_id={repr(self._spell_id)})"
+        return f"AvatarAdminServerPacket(byte_size={repr(self._byte_size)}, caster_id={repr(self._caster_id)}, victim_id={repr(self._victim_id)}, damage={repr(self._damage)}, caster_direction={repr(self._caster_direction)}, hp_percentage={repr(self._hp_percentage)}, victim_died={repr(self._victim_died)}, spell_id={repr(self._spell_id)})"

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AvatarAgreeServerPacket(Packet):
+    """
+    Nearby player changed appearance
+    """
     _byte_size: int = 0
     _change: AvatarChange = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class AvatarAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AvatarAgreeServerPacket): The data to serialize.
         """
-        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._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) -> "AvatarAgreeServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AvatarRemoveServerPacket(Packet):
+    """
+    Nearby player has disappeared from view
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _warp_effect: Optional[WarpEffect] = None # type: ignore [assignment]
@@ -90,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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AvatarReplyServerPacket(Packet):
+    """
+    Nearby player hit by another player
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _victim_id: int = None # type: ignore [assignment]
@@ -148,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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BankOpenServerPacket(Packet):
+    """
+    Open banker NPC interface
+    """
     _byte_size: int = 0
     _gold_bank: int = None # type: ignore [assignment]
     _session_id: int = None # type: ignore [assignment]
@@ -112,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":