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

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

@@ -105,20 +105,26 @@ class GuildAgreeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildAgreeClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._info_type is None:
-            raise SerializationError("info_type must be provided.")
-        writer.add_short(int(data._info_type))
-        if data._info_type == GuildInfoType.Description:
-            if not isinstance(data._info_type_data, GuildAgreeClientPacket.InfoTypeDataDescription):
-                raise SerializationError("Expected info_type_data to be type GuildAgreeClientPacket.InfoTypeDataDescription for info_type " + GuildInfoType(data._info_type).name + ".")
-            GuildAgreeClientPacket.InfoTypeDataDescription.serialize(writer, data._info_type_data)
-        elif data._info_type == GuildInfoType.Ranks:
-            if not isinstance(data._info_type_data, GuildAgreeClientPacket.InfoTypeDataRanks):
-                raise SerializationError("Expected info_type_data to be type GuildAgreeClientPacket.InfoTypeDataRanks for info_type " + GuildInfoType(data._info_type).name + ".")
-            GuildAgreeClientPacket.InfoTypeDataRanks.serialize(writer, data._info_type_data)
+        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)
+            if data._info_type is None:
+                raise SerializationError("info_type must be provided.")
+            writer.add_short(int(data._info_type))
+            if data._info_type == GuildInfoType.Description:
+                if not isinstance(data._info_type_data, GuildAgreeClientPacket.InfoTypeDataDescription):
+                    raise SerializationError("Expected info_type_data to be type GuildAgreeClientPacket.InfoTypeDataDescription for info_type " + GuildInfoType(data._info_type).name + ".")
+                GuildAgreeClientPacket.InfoTypeDataDescription.serialize(writer, data._info_type_data)
+            elif data._info_type == GuildInfoType.Ranks:
+                if not isinstance(data._info_type_data, GuildAgreeClientPacket.InfoTypeDataRanks):
+                    raise SerializationError("Expected info_type_data to be type GuildAgreeClientPacket.InfoTypeDataRanks for info_type " + GuildInfoType(data._info_type).name + ".")
+                GuildAgreeClientPacket.InfoTypeDataRanks.serialize(writer, data._info_type_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildAgreeClientPacket":
@@ -152,10 +158,9 @@ class GuildAgreeClientPacket(Packet):
         return f"GuildAgreeClientPacket(byte_size={repr(self._byte_size)}, session_id={repr(self._session_id)}, info_type={repr(self._info_type)}, info_type_data={repr(self._info_type_data)})"
 
     InfoTypeData = Union['GuildAgreeClientPacket.InfoTypeDataDescription', 'GuildAgreeClientPacket.InfoTypeDataRanks', None]
-    InfoTypeData.__doc__ = \
-        """
-        Data associated with different values of the `info_type` field.
-        """
+    """
+    Data associated with different values of the `info_type` field.
+    """
 
     class InfoTypeDataDescription:
         """
@@ -191,9 +196,13 @@ class GuildAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (GuildAgreeClientPacket.InfoTypeDataDescription): The data to serialize.
             """
-            if data._description is None:
-                raise SerializationError("description must be provided.")
-            writer.add_string(data._description)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._description is None:
+                    raise SerializationError("description must be provided.")
+                writer.add_string(data._description)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "GuildAgreeClientPacket.InfoTypeDataDescription":
@@ -261,14 +270,17 @@ class GuildAgreeClientPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (GuildAgreeClientPacket.InfoTypeDataRanks): The data to serialize.
             """
-            if data._ranks is None:
-                raise SerializationError("ranks must be provided.")
-            if len(data._ranks) != 9:
-                raise SerializationError(f"Expected length of ranks to be exactly 9, got {len(data._ranks)}.")
-            for i in range(9):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._ranks is None:
+                    raise SerializationError("ranks must be provided.")
+                if len(data._ranks) != 9:
+                    raise SerializationError(f"Expected length of ranks to be exactly 9, got {len(data._ranks)}.")
+                for i in range(9):
+                    writer.add_string(data._ranks[i])
                     writer.add_byte(0xFF)
-                writer.add_string(data._ranks[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "GuildAgreeClientPacket.InfoTypeDataRanks":
@@ -288,8 +300,7 @@ class GuildAgreeClientPacket(Packet):
                 data._ranks = []
                 for i in range(9):
                     data._ranks.append(reader.get_string())
-                    if i + 1 < 9:
-                        reader.next_chunk()
+                    reader.next_chunk()
                 data._byte_size = reader.position - reader_start_position
                 return data
             finally:

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

@@ -98,12 +98,16 @@ class GuildBuyClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildBuyClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_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._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_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) -> "GuildBuyClientPacket":

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

@@ -108,22 +108,28 @@ class GuildCreateClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildCreateClientPacket): 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._guild_tag is None:
-            raise SerializationError("guild_tag must be provided.")
-        writer.add_string(data._guild_tag)
-        writer.add_byte(0xFF)
-        if data._guild_name is None:
-            raise SerializationError("guild_name must be provided.")
-        writer.add_string(data._guild_name)
-        writer.add_byte(0xFF)
-        if data._description is None:
-            raise SerializationError("description must be provided.")
-        writer.add_string(data._description)
-        writer.add_byte(0xFF)
+        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._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            writer.add_string(data._guild_tag)
+            writer.add_byte(0xFF)
+            if data._guild_name is None:
+                raise SerializationError("guild_name must be provided.")
+            writer.add_string(data._guild_name)
+            writer.add_byte(0xFF)
+            if data._description is None:
+                raise SerializationError("description must be provided.")
+            writer.add_string(data._description)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildCreateClientPacket":

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

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

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

@@ -90,12 +90,16 @@ class GuildKickClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildKickClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._member_name is None:
-            raise SerializationError("member_name must be provided.")
-        writer.add_string(data._member_name)
+        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)
+            if data._member_name is None:
+                raise SerializationError("member_name must be provided.")
+            writer.add_string(data._member_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildKickClientPacket":

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

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

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

@@ -99,18 +99,24 @@ class GuildPlayerClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildPlayerClientPacket): 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._guild_tag is None:
-            raise SerializationError("guild_tag must be provided.")
-        writer.add_string(data._guild_tag)
-        writer.add_byte(0xFF)
-        if data._recruiter_name is None:
-            raise SerializationError("recruiter_name must be provided.")
-        writer.add_string(data._recruiter_name)
-        writer.add_byte(0xFF)
+        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._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            writer.add_string(data._guild_tag)
+            writer.add_byte(0xFF)
+            if data._recruiter_name is None:
+                raise SerializationError("recruiter_name must be provided.")
+            writer.add_string(data._recruiter_name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildPlayerClientPacket":

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

@@ -12,7 +12,7 @@ from .....data.eo_reader import EoReader
 
 class GuildRankClientPacket(Packet):
     """
-    Update a member's rank
+    Update a member's rank
     """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
@@ -107,15 +107,19 @@ class GuildRankClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildRankClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._rank is None:
-            raise SerializationError("rank must be provided.")
-        writer.add_char(data._rank)
-        if data._member_name is None:
-            raise SerializationError("member_name must be provided.")
-        writer.add_string(data._member_name)
+        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)
+            if data._rank is None:
+                raise SerializationError("rank must be provided.")
+            writer.add_char(data._rank)
+            if data._member_name is None:
+                raise SerializationError("member_name must be provided.")
+            writer.add_string(data._member_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildRankClientPacket":

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

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

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

@@ -90,12 +90,16 @@ class GuildReportClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildReportClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._guild_identity is None:
-            raise SerializationError("guild_identity must be provided.")
-        writer.add_string(data._guild_identity)
+        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)
+            if data._guild_identity is None:
+                raise SerializationError("guild_identity must be provided.")
+            writer.add_string(data._guild_identity)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildReportClientPacket":

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

@@ -99,18 +99,24 @@ class GuildRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildRequestClientPacket): 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._guild_tag is None:
-            raise SerializationError("guild_tag must be provided.")
-        writer.add_string(data._guild_tag)
-        writer.add_byte(0xFF)
-        if data._guild_name is None:
-            raise SerializationError("guild_name must be provided.")
-        writer.add_string(data._guild_name)
-        writer.add_byte(0xFF)
+        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._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            writer.add_string(data._guild_tag)
+            writer.add_byte(0xFF)
+            if data._guild_name is None:
+                raise SerializationError("guild_name must be provided.")
+            writer.add_string(data._guild_name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildRequestClientPacket":

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

@@ -18,6 +18,7 @@ class GuildTakeClientPacket(Packet):
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _info_type: GuildInfoType = None # type: ignore [assignment]
+    _guild_tag: str = None # type: ignore [assignment]
 
     @property
     def byte_size(self) -> int:
@@ -53,6 +54,22 @@ class GuildTakeClientPacket(Packet):
     def info_type(self, info_type: GuildInfoType) -> None:
         self._info_type = info_type
 
+    @property
+    def guild_tag(self) -> str:
+        """
+        Note:
+          - Length must be `3`.
+        """
+        return self._guild_tag
+
+    @guild_tag.setter
+    def guild_tag(self, guild_tag: str) -> None:
+        """
+        Note:
+          - Length must be `3`.
+        """
+        self._guild_tag = guild_tag
+
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -91,12 +108,21 @@ class GuildTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildTakeClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._info_type is None:
-            raise SerializationError("info_type must be provided.")
-        writer.add_short(int(data._info_type))
+        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)
+            if data._info_type is None:
+                raise SerializationError("info_type must be provided.")
+            writer.add_short(int(data._info_type))
+            if data._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            if len(data._guild_tag) != 3:
+                raise SerializationError(f"Expected length of guild_tag to be exactly 3, got {len(data._guild_tag)}.")
+            writer.add_fixed_string(data._guild_tag, 3, False)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildTakeClientPacket":
@@ -115,10 +141,11 @@ class GuildTakeClientPacket(Packet):
             reader_start_position: int = reader.position
             data._session_id = reader.get_int()
             data._info_type = GuildInfoType(reader.get_short())
+            data._guild_tag = reader.get_fixed_string(3, False)
             data._byte_size = reader.position - reader_start_position
             return data
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
     def __repr__(self):
-        return f"GuildTakeClientPacket(byte_size={repr(self._byte_size)}, session_id={repr(self._session_id)}, info_type={repr(self._info_type)})"
+        return f"GuildTakeClientPacket(byte_size={repr(self._byte_size)}, session_id={repr(self._session_id)}, info_type={repr(self._info_type)}, guild_tag={repr(self._guild_tag)})"

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

@@ -90,12 +90,16 @@ class GuildTellClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildTellClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
-        if data._guild_identity is None:
-            raise SerializationError("guild_identity must be provided.")
-        writer.add_string(data._guild_identity)
+        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)
+            if data._guild_identity is None:
+                raise SerializationError("guild_identity must be provided.")
+            writer.add_string(data._guild_identity)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildTellClientPacket":

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

@@ -81,9 +81,13 @@ class GuildUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildUseClientPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_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)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildUseClientPacket":

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

@@ -111,21 +111,25 @@ class InitInitClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (InitInitClientPacket): The data to serialize.
         """
-        if data._challenge is None:
-            raise SerializationError("challenge must be provided.")
-        writer.add_three(data._challenge)
-        if data._version is None:
-            raise SerializationError("version must be provided.")
-        Version.serialize(writer, data._version)
-        writer.add_char(112)
-        if data._hdid_length is None:
-            raise SerializationError("hdid_length must be provided.")
-        writer.add_char(data._hdid_length)
-        if data._hdid is None:
-            raise SerializationError("hdid must be provided.")
-        if len(data._hdid) > 252:
-            raise SerializationError(f"Expected length of hdid to be 252 or less, got {len(data._hdid)}.")
-        writer.add_fixed_string(data._hdid, data._hdid_length, False)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._challenge is None:
+                raise SerializationError("challenge must be provided.")
+            writer.add_three(data._challenge)
+            if data._version is None:
+                raise SerializationError("version must be provided.")
+            Version.serialize(writer, data._version)
+            writer.add_char(112)
+            if data._hdid_length is None:
+                raise SerializationError("hdid_length must be provided.")
+            writer.add_char(data._hdid_length)
+            if data._hdid is None:
+                raise SerializationError("hdid must be provided.")
+            if len(data._hdid) > 252:
+                raise SerializationError(f"Expected length of hdid to be 252 or less, got {len(data._hdid)}.")
+            writer.add_fixed_string(data._hdid, data._hdid_length, False)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "InitInitClientPacket":

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

@@ -43,7 +43,7 @@ class ItemDropClientPacket(Packet):
         """
         The official client sends 255 byte values for the coords if an item is dropped via
         the GUI button.
-        255 values here should be interpreted to mean "drop at current coords".
+        255 values here should be interpreted to mean "drop at current coords".
         Otherwise, the x and y fields contain encoded numbers that must be explicitly
         decoded to get the actual x and y values.
         """
@@ -54,7 +54,7 @@ class ItemDropClientPacket(Packet):
         """
         The official client sends 255 byte values for the coords if an item is dropped via
         the GUI button.
-        255 values here should be interpreted to mean "drop at current coords".
+        255 values here should be interpreted to mean "drop at current coords".
         Otherwise, the x and y fields contain encoded numbers that must be explicitly
         decoded to get the actual x and y values.
         """
@@ -98,12 +98,16 @@ class ItemDropClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemDropClientPacket): The data to serialize.
         """
-        if data._item is None:
-            raise SerializationError("item must be provided.")
-        ThreeItem.serialize(writer, data._item)
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        ByteCoords.serialize(writer, data._coords)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item is None:
+                raise SerializationError("item must be provided.")
+            ThreeItem.serialize(writer, data._item)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            ByteCoords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemDropClientPacket":

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

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

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

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