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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkOpenServerPacket(Packet):
+    """
+    Party chat message
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -87,12 +90,16 @@ class TalkOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkOpenServerPacket): 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._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        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._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkOpenServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkPlayerServerPacket(Packet):
+    """
+    Public chat message
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -87,12 +90,16 @@ class TalkPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkPlayerServerPacket): 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._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        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._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkPlayerServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkReplyServerPacket(Packet):
+    """
+    Reply to trying to send a private message
+    """
     _byte_size: int = 0
     _reply_code: TalkReply = None # type: ignore [assignment]
     _name: str = None # type: ignore [assignment]
@@ -80,12 +83,16 @@ class TalkReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkReplyServerPacket): 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._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
+        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._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkReplyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkRequestServerPacket(Packet):
+    """
+    Guild chat message
+    """
     _byte_size: int = 0
     _player_name: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class TalkRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkRequestServerPacket): 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) -> "TalkRequestServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkServerServerPacket(Packet):
+    """
+    Server message
+    """
     _byte_size: int = 0
     _message: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkServerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkServerServerPacket): The data to serialize.
         """
-        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:
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkServerServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkSpecServerPacket(Packet):
+    """
+    Temporary mute applied
+    """
     _byte_size: int = 0
     _admin_name: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TalkSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkSpecServerPacket): The data to serialize.
         """
-        if data._admin_name is None:
-            raise SerializationError("admin_name must be provided.")
-        writer.add_string(data._admin_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._admin_name is None:
+                raise SerializationError("admin_name must be provided.")
+            writer.add_string(data._admin_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TalkSpecServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TalkTellServerPacket(Packet):
+    """
+    Private chat message
+    """
     _byte_size: int = 0
     _player_name: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class TalkTellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TalkTellServerPacket): 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) -> "TalkTellServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeAdminServerPacket(Packet):
+    """
+    Trade updated (items changed while trade was accepted)
+    """
     _byte_size: int = 0
     _trade_data: TradeItemData = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class TradeAdminServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAdminServerPacket): The data to serialize.
         """
-        if data._trade_data is None:
-            raise SerializationError("trade_data must be provided.")
-        TradeItemData.serialize(writer, data._trade_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._trade_data is None:
+                raise SerializationError("trade_data must be provided.")
+            TradeItemData.serialize(writer, data._trade_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeAdminServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeAgreeServerPacket(Packet):
+    """
+    Partner agree state updated
+    """
     _byte_size: int = 0
     _partner_player_id: int = None # type: ignore [assignment]
     _agree: bool = None # type: ignore [assignment]
@@ -87,12 +90,16 @@ class TradeAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeAgreeServerPacket): The data to serialize.
         """
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._agree is None:
-            raise SerializationError("agree must be provided.")
-        writer.add_char(1 if data._agree else 0)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._agree is None:
+                raise SerializationError("agree must be provided.")
+            writer.add_char(1 if data._agree else 0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeAgreeServerPacket":

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

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

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

@@ -86,22 +86,28 @@ class TradeItemData:
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeItemData): The data to serialize.
         """
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._partner_items is None:
-            raise SerializationError("partner_items must be provided.")
-        for i in range(len(data._partner_items)):
-            Item.serialize(writer, data._partner_items[i])
-        writer.add_byte(0xFF)
-        if data._your_player_id is None:
-            raise SerializationError("your_player_id must be provided.")
-        writer.add_short(data._your_player_id)
-        if data._your_items is None:
-            raise SerializationError("your_items must be provided.")
-        for i in range(len(data._your_items)):
-            Item.serialize(writer, data._your_items[i])
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._partner_items is None:
+                raise SerializationError("partner_items must be provided.")
+            for i in range(len(data._partner_items)):
+                Item.serialize(writer, data._partner_items[i])
+            writer.add_byte(0xFF)
+            if data._your_player_id is None:
+                raise SerializationError("your_player_id must be provided.")
+            writer.add_short(data._your_player_id)
+            if data._your_items is None:
+                raise SerializationError("your_items must be provided.")
+            for i in range(len(data._your_items)):
+                Item.serialize(writer, data._your_items[i])
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeItemData":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeOpenServerPacket(Packet):
+    """
+    Trade window opens
+    """
     _byte_size: int = 0
     _partner_player_id: int = None # type: ignore [assignment]
     _partner_player_name: str = None # type: ignore [assignment]
@@ -113,20 +116,26 @@ class TradeOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeOpenServerPacket): The data to serialize.
         """
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._partner_player_name is None:
-            raise SerializationError("partner_player_name must be provided.")
-        writer.add_string(data._partner_player_name)
-        writer.add_byte(0xFF)
-        if data._your_player_id is None:
-            raise SerializationError("your_player_id must be provided.")
-        writer.add_short(data._your_player_id)
-        if data._your_player_name is None:
-            raise SerializationError("your_player_name must be provided.")
-        writer.add_string(data._your_player_name)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._partner_player_name is None:
+                raise SerializationError("partner_player_name must be provided.")
+            writer.add_string(data._partner_player_name)
+            writer.add_byte(0xFF)
+            if data._your_player_id is None:
+                raise SerializationError("your_player_id must be provided.")
+            writer.add_short(data._your_player_id)
+            if data._your_player_name is None:
+                raise SerializationError("your_player_name must be provided.")
+            writer.add_string(data._your_player_name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeOpenServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeReplyServerPacket(Packet):
+    """
+    Trade updated (items changed)
+    """
     _byte_size: int = 0
     _trade_data: TradeItemData = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class TradeReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeReplyServerPacket): The data to serialize.
         """
-        if data._trade_data is None:
-            raise SerializationError("trade_data must be provided.")
-        TradeItemData.serialize(writer, data._trade_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._trade_data is None:
+                raise SerializationError("trade_data must be provided.")
+            TradeItemData.serialize(writer, data._trade_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeReplyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeRequestServerPacket(Packet):
+    """
+    Trade request from another player
+    """
     _byte_size: int = 0
     _partner_player_id: int = None # type: ignore [assignment]
     _partner_player_name: str = None # type: ignore [assignment]
@@ -87,13 +90,17 @@ class TradeRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeRequestServerPacket): The data to serialize.
         """
-        writer.add_char(138)
-        if data._partner_player_id is None:
-            raise SerializationError("partner_player_id must be provided.")
-        writer.add_short(data._partner_player_id)
-        if data._partner_player_name is None:
-            raise SerializationError("partner_player_name must be provided.")
-        writer.add_string(data._partner_player_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_char(138)
+            if data._partner_player_id is None:
+                raise SerializationError("partner_player_id must be provided.")
+            writer.add_short(data._partner_player_id)
+            if data._partner_player_name is None:
+                raise SerializationError("partner_player_name must be provided.")
+            writer.add_string(data._partner_player_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeRequestServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeSpecServerPacket(Packet):
+    """
+    Own agree state updated
+    """
     _byte_size: int = 0
     _agree: bool = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class TradeSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeSpecServerPacket): The data to serialize.
         """
-        if data._agree is None:
-            raise SerializationError("agree must be provided.")
-        writer.add_char(1 if data._agree else 0)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._agree is None:
+                raise SerializationError("agree must be provided.")
+            writer.add_char(1 if data._agree else 0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeSpecServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class TradeUseServerPacket(Packet):
+    """
+    Trade completed
+    """
     _byte_size: int = 0
     _trade_data: TradeItemData = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class TradeUseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (TradeUseServerPacket): The data to serialize.
         """
-        if data._trade_data is None:
-            raise SerializationError("trade_data must be provided.")
-        TradeItemData.serialize(writer, data._trade_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._trade_data is None:
+                raise SerializationError("trade_data must be provided.")
+            TradeItemData.serialize(writer, data._trade_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "TradeUseServerPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WalkCloseServerPacket(Packet):
+    """
+    Your character has been frozen
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class WalkCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkCloseServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_string("S")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkCloseServerPacket":
@@ -79,8 +84,7 @@ class WalkCloseServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WalkOpenServerPacket(Packet):
+    """
+    Your character has been unfrozen
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class WalkOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkOpenServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_string("S")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkOpenServerPacket":
@@ -79,8 +84,7 @@ class WalkOpenServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_string()
+            reader.get_string()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class WalkPlayerServerPacket(Packet):
+    """
+    Nearby player has walked
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _direction: Direction = None # type: ignore [assignment]
@@ -118,15 +121,19 @@ class WalkPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (WalkPlayerServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "WalkPlayerServerPacket":