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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellRequestServerPacket(Packet):
+    """
+    Nearby player chanting a spell
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _spell_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class SpellRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellRequestServerPacket): 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._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._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            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) -> "SpellRequestServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellTargetGroupServerPacket(Packet):
+    """
+    Nearby player(s) hit by a group heal spell from a player
+    """
     _byte_size: int = 0
     _spell_id: int = None # type: ignore [assignment]
     _caster_id: int = None # type: ignore [assignment]
@@ -140,22 +143,26 @@ class SpellTargetGroupServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetGroupServerPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._caster_id is None:
-            raise SerializationError("caster_id must be provided.")
-        writer.add_short(data._caster_id)
-        if data._caster_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_short(data._spell_heal_hp)
-        if data._players is None:
-            raise SerializationError("players must be provided.")
-        for i in range(len(data._players)):
-            GroupHealTargetPlayer.serialize(writer, data._players[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._caster_id is None:
+                raise SerializationError("caster_id must be provided.")
+            writer.add_short(data._caster_id)
+            if data._caster_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_short(data._spell_heal_hp)
+            if data._players is None:
+                raise SerializationError("players must be provided.")
+            for i in range(len(data._players)):
+                GroupHealTargetPlayer.serialize(writer, data._players[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetGroupServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellTargetOtherServerPacket(Packet):
+    """
+    Nearby player hit by a heal spell from a player
+    """
     _byte_size: int = 0
     _victim_id: int = None # type: ignore [assignment]
     _caster_id: int = None # type: ignore [assignment]
@@ -175,27 +178,31 @@ class SpellTargetOtherServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetOtherServerPacket): The data to serialize.
         """
-        if data._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._caster_id is None:
-            raise SerializationError("caster_id must be provided.")
-        writer.add_short(data._caster_id)
-        if data._caster_direction is None:
-            raise SerializationError("caster_direction must be provided.")
-        writer.add_char(int(data._caster_direction))
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_int(data._spell_heal_hp)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._victim_id is None:
+                raise SerializationError("victim_id must be provided.")
+            writer.add_short(data._victim_id)
+            if data._caster_id is None:
+                raise SerializationError("caster_id must be provided.")
+            writer.add_short(data._caster_id)
+            if data._caster_direction is None:
+                raise SerializationError("caster_direction must be provided.")
+            writer.add_char(int(data._caster_direction))
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_int(data._spell_heal_hp)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetOtherServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class SpellTargetSelfServerPacket(Packet):
+    """
+    Nearby player self-casted a spell
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _spell_id: int = None # type: ignore [assignment]
@@ -173,24 +176,28 @@ class SpellTargetSelfServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetSelfServerPacket): 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._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_int(data._spell_heal_hp)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
-        reached_missing_optional = reached_missing_optional or data._tp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._tp))
+        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._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_int(data._spell_heal_hp)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+            reached_missing_optional = reached_missing_optional or data._tp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._tp))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetSelfServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillAcceptServerPacket(Packet):
+    """
+    Response to spending skill points
+    """
     _byte_size: int = 0
     _skill_points: int = None # type: ignore [assignment]
     _spell: Spell = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class StatSkillAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillAcceptServerPacket): The data to serialize.
         """
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._spell is None:
-            raise SerializationError("spell must be provided.")
-        Spell.serialize(writer, data._spell)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._spell is None:
+                raise SerializationError("spell must be provided.")
+            Spell.serialize(writer, data._spell)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillAcceptServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillJunkServerPacket(Packet):
+    """
+    Response to resetting stats and skills at a skill master
+    """
     _byte_size: int = 0
     _stats: CharacterStatsReset = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class StatSkillJunkServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillJunkServerPacket): The data to serialize.
         """
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsReset.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsReset.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillJunkServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillOpenServerPacket(Packet):
+    """
+    Response from talking to a skill master NPC
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _shop_name: str = None # type: ignore [assignment]
@@ -98,17 +101,23 @@ class StatSkillOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillOpenServerPacket): 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._skills is None:
-            raise SerializationError("skills must be provided.")
-        for i in range(len(data._skills)):
-            SkillLearn.serialize(writer, data._skills[i])
+        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._skills is None:
+                raise SerializationError("skills must be provided.")
+            for i in range(len(data._skills)):
+                SkillLearn.serialize(writer, data._skills[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillOpenServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillPlayerServerPacket(Packet):
+    """
+    Response to spending stat points
+    """
     _byte_size: int = 0
     _stat_points: int = None # type: ignore [assignment]
     _stats: CharacterStatsUpdate = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class StatSkillPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillPlayerServerPacket): The data to serialize.
         """
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsUpdate.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsUpdate.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillPlayerServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillRemoveServerPacket(Packet):
+    """
+    Response to forgetting a skill at a skill master
+    """
     _byte_size: int = 0
     _spell_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class StatSkillRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillRemoveServerPacket): The data to serialize.
         """
-        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._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) -> "StatSkillRemoveServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillReplyServerPacket(Packet):
+    """
+    Response from unsuccessful action at a skill master
+    """
     _byte_size: int = 0
     _reply_code: SkillMasterReply = None # type: ignore [assignment]
     _reply_code_data: 'StatSkillReplyServerPacket.ReplyCodeData' = None
@@ -84,13 +87,17 @@ class StatSkillReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == SkillMasterReply.WrongClass:
-            if not isinstance(data._reply_code_data, StatSkillReplyServerPacket.ReplyCodeDataWrongClass):
-                raise SerializationError("Expected reply_code_data to be type StatSkillReplyServerPacket.ReplyCodeDataWrongClass for reply_code " + SkillMasterReply(data._reply_code).name + ".")
-            StatSkillReplyServerPacket.ReplyCodeDataWrongClass.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+            if data._reply_code == SkillMasterReply.WrongClass:
+                if not isinstance(data._reply_code_data, StatSkillReplyServerPacket.ReplyCodeDataWrongClass):
+                    raise SerializationError("Expected reply_code_data to be type StatSkillReplyServerPacket.ReplyCodeDataWrongClass for reply_code " + SkillMasterReply(data._reply_code).name + ".")
+                StatSkillReplyServerPacket.ReplyCodeDataWrongClass.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillReplyServerPacket":
@@ -119,10 +126,9 @@ class StatSkillReplyServerPacket(Packet):
         return f"StatSkillReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['StatSkillReplyServerPacket.ReplyCodeDataWrongClass', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataWrongClass:
         """
@@ -166,9 +172,13 @@ class StatSkillReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (StatSkillReplyServerPacket.ReplyCodeDataWrongClass): The data to serialize.
             """
-            if data._class_id is None:
-                raise SerializationError("class_id must be provided.")
-            writer.add_char(data._class_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._class_id is None:
+                    raise SerializationError("class_id must be provided.")
+                writer.add_char(data._class_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "StatSkillReplyServerPacket.ReplyCodeDataWrongClass":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class StatSkillTakeServerPacket(Packet):
+    """
+    Response from learning a skill from a skill master
+    """
     _byte_size: int = 0
     _spell_id: int = None # type: ignore [assignment]
     _gold_amount: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class StatSkillTakeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillTakeServerPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillTakeServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkAdminServerPacket(Packet):
+    """
+    Admin chat message
+    """
     _byte_size: int = 0
     _player_name: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class TalkAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkAdminServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkAdminServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkAnnounceServerPacket(Packet):
+    """
+    Admin announcement
+    """
     _byte_size: int = 0
     _player_name: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class TalkAnnounceServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkAnnounceServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkAnnounceServerPacket":

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

@@ -13,6 +13,10 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkListServerPacket(Packet):
+    """
+    Global chat backfill.
+    Sent by the official game server when a player opens the global chat tab.
+    """
     _byte_size: int = 0
     _messages: list[GlobalBackfillMessage] = None # type: ignore [assignment]
 
@@ -72,12 +76,17 @@ class TalkListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkListServerPacket): The data to serialize.
         """
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        for i in range(len(data._messages)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            for i in range(len(data._messages)):
+                GlobalBackfillMessage.serialize(writer, data._messages[i])
                 writer.add_byte(0xFF)
-            GlobalBackfillMessage.serialize(writer, data._messages[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkListServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkMsgServerPacket(Packet):
+    """
+    Global chat message
+    """
     _byte_size: int = 0
     _player_name: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class TalkMsgServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkMsgServerPacket): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkMsgServerPacket":