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

eolib/protocol/_generated/net/client/priest_request_client_packet.py

@@ -90,13 +90,19 @@ class PriestRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PriestRequestClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        writer.add_byte(0xFF)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        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_int(data._session_id)
+            writer.add_byte(0xFF)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PriestRequestClientPacket":

eolib/protocol/_generated/net/client/priest_use_client_packet.py

@@ -12,7 +12,7 @@ from .....data.eo_reader import EoReader
 
 class PriestUseClientPacket(Packet):
     """
-    Saying "I do" at a wedding
+    Saying "I do" at a wedding
     """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
@@ -81,9 +81,13 @@ class PriestUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PriestUseClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PriestUseClientPacket":

eolib/protocol/_generated/net/client/quest_accept_client_packet.py

@@ -155,25 +155,29 @@ class QuestAcceptClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestAcceptClientPacket): 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._dialog_id is None:
-            raise SerializationError("dialog_id must be provided.")
-        writer.add_short(data._dialog_id)
-        if data._quest_id is None:
-            raise SerializationError("quest_id must be provided.")
-        writer.add_short(data._quest_id)
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        if data._reply_type is None:
-            raise SerializationError("reply_type must be provided.")
-        writer.add_char(int(data._reply_type))
-        if data._reply_type == DialogReply.Link:
-            if not isinstance(data._reply_type_data, QuestAcceptClientPacket.ReplyTypeDataLink):
-                raise SerializationError("Expected reply_type_data to be type QuestAcceptClientPacket.ReplyTypeDataLink for reply_type " + DialogReply(data._reply_type).name + ".")
-            QuestAcceptClientPacket.ReplyTypeDataLink.serialize(writer, data._reply_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._dialog_id is None:
+                raise SerializationError("dialog_id must be provided.")
+            writer.add_short(data._dialog_id)
+            if data._quest_id is None:
+                raise SerializationError("quest_id must be provided.")
+            writer.add_short(data._quest_id)
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            if data._reply_type is None:
+                raise SerializationError("reply_type must be provided.")
+            writer.add_char(int(data._reply_type))
+            if data._reply_type == DialogReply.Link:
+                if not isinstance(data._reply_type_data, QuestAcceptClientPacket.ReplyTypeDataLink):
+                    raise SerializationError("Expected reply_type_data to be type QuestAcceptClientPacket.ReplyTypeDataLink for reply_type " + DialogReply(data._reply_type).name + ".")
+                QuestAcceptClientPacket.ReplyTypeDataLink.serialize(writer, data._reply_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestAcceptClientPacket":
@@ -206,10 +210,9 @@ class QuestAcceptClientPacket(Packet):
         return f"QuestAcceptClientPacket(byte_size={repr(self._byte_size)}, session_id={repr(self._session_id)}, dialog_id={repr(self._dialog_id)}, quest_id={repr(self._quest_id)}, npc_index={repr(self._npc_index)}, reply_type={repr(self._reply_type)}, reply_type_data={repr(self._reply_type_data)})"
 
     ReplyTypeData = Union['QuestAcceptClientPacket.ReplyTypeDataLink', None]
-    ReplyTypeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_type` field.
-        """
+    """
+    Data associated with different values of the `reply_type` field.
+    """
 
     class ReplyTypeDataLink:
         """
@@ -253,9 +256,13 @@ class QuestAcceptClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (QuestAcceptClientPacket.ReplyTypeDataLink): The data to serialize.
             """
-            if data._action is None:
-                raise SerializationError("action must be provided.")
-            writer.add_char(data._action)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._action is None:
+                    raise SerializationError("action must be provided.")
+                writer.add_char(data._action)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "QuestAcceptClientPacket.ReplyTypeDataLink":

eolib/protocol/_generated/net/client/quest_list_client_packet.py

@@ -74,9 +74,13 @@ class QuestListClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestListClientPacket): The data to serialize.
         """
-        if data._page is None:
-            raise SerializationError("page must be provided.")
-        writer.add_char(int(data._page))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._page is None:
+                raise SerializationError("page must be provided.")
+            writer.add_char(int(data._page))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestListClientPacket":

eolib/protocol/_generated/net/client/quest_use_client_packet.py

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

eolib/protocol/_generated/net/client/range_request_client_packet.py

@@ -99,15 +99,21 @@ class RangeRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RangeRequestClientPacket): The data to serialize.
         """
-        if data._player_ids is None:
-            raise SerializationError("player_ids must be provided.")
-        for i in range(len(data._player_ids)):
-            writer.add_short(data._player_ids[i])
-        writer.add_byte(0xFF)
-        if data._npc_indexes is None:
-            raise SerializationError("npc_indexes must be provided.")
-        for i in range(len(data._npc_indexes)):
-            writer.add_char(data._npc_indexes[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_ids is None:
+                raise SerializationError("player_ids must be provided.")
+            for i in range(len(data._player_ids)):
+                writer.add_short(data._player_ids[i])
+            writer.add_byte(0xFF)
+            if data._npc_indexes is None:
+                raise SerializationError("npc_indexes must be provided.")
+            for i in range(len(data._npc_indexes)):
+                writer.add_char(data._npc_indexes[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RangeRequestClientPacket":

eolib/protocol/_generated/net/client/refresh_request_client_packet.py

@@ -63,9 +63,11 @@ class RefreshRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RefreshRequestClientPacket): 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) -> "RefreshRequestClientPacket":
@@ -82,8 +84,7 @@ class RefreshRequestClientPacket(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/client/shop_buy_client_packet.py

@@ -91,12 +91,16 @@ class ShopBuyClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopBuyClientPacket): The data to serialize.
         """
-        if data._buy_item is None:
-            raise SerializationError("buy_item must be provided.")
-        Item.serialize(writer, data._buy_item)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._buy_item is None:
+                raise SerializationError("buy_item must be provided.")
+            Item.serialize(writer, data._buy_item)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopBuyClientPacket":

eolib/protocol/_generated/net/client/shop_create_client_packet.py

@@ -98,12 +98,16 @@ class ShopCreateClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCreateClientPacket): The data to serialize.
         """
-        if data._craft_item_id is None:
-            raise SerializationError("craft_item_id must be provided.")
-        writer.add_short(data._craft_item_id)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._craft_item_id is None:
+                raise SerializationError("craft_item_id must be provided.")
+            writer.add_short(data._craft_item_id)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCreateClientPacket":

eolib/protocol/_generated/net/client/shop_open_client_packet.py

@@ -81,9 +81,13 @@ class ShopOpenClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopOpenClientPacket): The data to serialize.
         """
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopOpenClientPacket":

eolib/protocol/_generated/net/client/shop_sell_client_packet.py

@@ -91,12 +91,16 @@ class ShopSellClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopSellClientPacket): The data to serialize.
         """
-        if data._sell_item is None:
-            raise SerializationError("sell_item must be provided.")
-        Item.serialize(writer, data._sell_item)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sell_item is None:
+                raise SerializationError("sell_item must be provided.")
+            Item.serialize(writer, data._sell_item)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopSellClientPacket":

eolib/protocol/_generated/net/client/sit_request_client_packet.py

@@ -88,13 +88,17 @@ class SitRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitRequestClientPacket): The data to serialize.
         """
-        if data._sit_action is None:
-            raise SerializationError("sit_action must be provided.")
-        writer.add_char(int(data._sit_action))
-        if data._sit_action == SitAction.Sit:
-            if not isinstance(data._sit_action_data, SitRequestClientPacket.SitActionDataSit):
-                raise SerializationError("Expected sit_action_data to be type SitRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
-            SitRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sit_action is None:
+                raise SerializationError("sit_action must be provided.")
+            writer.add_char(int(data._sit_action))
+            if data._sit_action == SitAction.Sit:
+                if not isinstance(data._sit_action_data, SitRequestClientPacket.SitActionDataSit):
+                    raise SerializationError("Expected sit_action_data to be type SitRequestClientPacket.SitActionDataSit for sit_action " + SitAction(data._sit_action).name + ".")
+                SitRequestClientPacket.SitActionDataSit.serialize(writer, data._sit_action_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitRequestClientPacket":
@@ -123,10 +127,9 @@ class SitRequestClientPacket(Packet):
         return f"SitRequestClientPacket(byte_size={repr(self._byte_size)}, sit_action={repr(self._sit_action)}, sit_action_data={repr(self._sit_action_data)})"
 
     SitActionData = Union['SitRequestClientPacket.SitActionDataSit', None]
-    SitActionData.__doc__ = \
-        """
-        Data associated with different values of the `sit_action` field.
-        """
+    """
+    Data associated with different values of the `sit_action` field.
+    """
 
     class SitActionDataSit:
         """
@@ -168,9 +171,13 @@ class SitRequestClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (SitRequestClientPacket.SitActionDataSit): The data to serialize.
             """
-            if data._cursor_coords is None:
-                raise SerializationError("cursor_coords must be provided.")
-            Coords.serialize(writer, data._cursor_coords)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._cursor_coords is None:
+                    raise SerializationError("cursor_coords must be provided.")
+                Coords.serialize(writer, data._cursor_coords)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "SitRequestClientPacket.SitActionDataSit":

eolib/protocol/_generated/net/client/spell_request_client_packet.py

@@ -98,12 +98,16 @@ class SpellRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellRequestClientPacket): 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._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        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._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellRequestClientPacket":

eolib/protocol/_generated/net/client/spell_target_group_client_packet.py

@@ -98,12 +98,16 @@ class SpellTargetGroupClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetGroupClientPacket): 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._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        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._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetGroupClientPacket":

eolib/protocol/_generated/net/client/spell_target_other_client_packet.py

@@ -142,21 +142,25 @@ class SpellTargetOtherClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetOtherClientPacket): The data to serialize.
         """
-        if data._target_type is None:
-            raise SerializationError("target_type must be provided.")
-        writer.add_char(int(data._target_type))
-        if data._previous_timestamp is None:
-            raise SerializationError("previous_timestamp must be provided.")
-        writer.add_three(data._previous_timestamp)
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._victim_id is None:
-            raise SerializationError("victim_id must be provided.")
-        writer.add_short(data._victim_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._target_type is None:
+                raise SerializationError("target_type must be provided.")
+            writer.add_char(int(data._target_type))
+            if data._previous_timestamp is None:
+                raise SerializationError("previous_timestamp must be provided.")
+            writer.add_three(data._previous_timestamp)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._victim_id is None:
+                raise SerializationError("victim_id must be provided.")
+            writer.add_short(data._victim_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetOtherClientPacket":

eolib/protocol/_generated/net/client/spell_target_self_client_packet.py

@@ -108,15 +108,19 @@ class SpellTargetSelfClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetSelfClientPacket): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetSelfClientPacket":

eolib/protocol/_generated/net/client/spell_use_client_packet.py

@@ -74,9 +74,13 @@ class SpellUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellUseClientPacket): The data to serialize.
         """
-        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._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) -> "SpellUseClientPacket":

eolib/protocol/_generated/net/client/stat_skill_add_client_packet.py

@@ -88,17 +88,21 @@ class StatSkillAddClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillAddClientPacket): The data to serialize.
         """
-        if data._action_type is None:
-            raise SerializationError("action_type must be provided.")
-        writer.add_char(int(data._action_type))
-        if data._action_type == TrainType.Stat:
-            if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataStat):
-                raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataStat for action_type " + TrainType(data._action_type).name + ".")
-            StatSkillAddClientPacket.ActionTypeDataStat.serialize(writer, data._action_type_data)
-        elif data._action_type == TrainType.Skill:
-            if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataSkill):
-                raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataSkill for action_type " + TrainType(data._action_type).name + ".")
-            StatSkillAddClientPacket.ActionTypeDataSkill.serialize(writer, data._action_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._action_type is None:
+                raise SerializationError("action_type must be provided.")
+            writer.add_char(int(data._action_type))
+            if data._action_type == TrainType.Stat:
+                if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataStat):
+                    raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataStat for action_type " + TrainType(data._action_type).name + ".")
+                StatSkillAddClientPacket.ActionTypeDataStat.serialize(writer, data._action_type_data)
+            elif data._action_type == TrainType.Skill:
+                if not isinstance(data._action_type_data, StatSkillAddClientPacket.ActionTypeDataSkill):
+                    raise SerializationError("Expected action_type_data to be type StatSkillAddClientPacket.ActionTypeDataSkill for action_type " + TrainType(data._action_type).name + ".")
+                StatSkillAddClientPacket.ActionTypeDataSkill.serialize(writer, data._action_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillAddClientPacket":
@@ -129,10 +133,9 @@ class StatSkillAddClientPacket(Packet):
         return f"StatSkillAddClientPacket(byte_size={repr(self._byte_size)}, action_type={repr(self._action_type)}, action_type_data={repr(self._action_type_data)})"
 
     ActionTypeData = Union['StatSkillAddClientPacket.ActionTypeDataStat', 'StatSkillAddClientPacket.ActionTypeDataSkill', None]
-    ActionTypeData.__doc__ = \
-        """
-        Data associated with different values of the `action_type` field.
-        """
+    """
+    Data associated with different values of the `action_type` field.
+    """
 
     class ActionTypeDataStat:
         """
@@ -168,9 +171,13 @@ class StatSkillAddClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (StatSkillAddClientPacket.ActionTypeDataStat): The data to serialize.
             """
-            if data._stat_id is None:
-                raise SerializationError("stat_id must be provided.")
-            writer.add_short(int(data._stat_id))
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._stat_id is None:
+                    raise SerializationError("stat_id must be provided.")
+                writer.add_short(int(data._stat_id))
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "StatSkillAddClientPacket.ActionTypeDataStat":
@@ -238,9 +245,13 @@ class StatSkillAddClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (StatSkillAddClientPacket.ActionTypeDataSkill): 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) -> "StatSkillAddClientPacket.ActionTypeDataSkill":

eolib/protocol/_generated/net/client/stat_skill_junk_client_packet.py

@@ -81,9 +81,13 @@ class StatSkillJunkClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (StatSkillJunkClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "StatSkillJunkClientPacket":