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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BankReplyServerPacket(Packet):
+    """
+    Update gold counts after deposit/withdraw
+    """
     _byte_size: int = 0
     _gold_inventory: int = None # type: ignore [assignment]
     _gold_bank: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class BankReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BankReplyServerPacket): The data to serialize.
         """
-        if data._gold_inventory is None:
-            raise SerializationError("gold_inventory must be provided.")
-        writer.add_int(data._gold_inventory)
-        if data._gold_bank is None:
-            raise SerializationError("gold_bank must be provided.")
-        writer.add_int(data._gold_bank)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._gold_inventory is None:
+                raise SerializationError("gold_inventory must be provided.")
+            writer.add_int(data._gold_inventory)
+            if data._gold_bank is None:
+                raise SerializationError("gold_bank must be provided.")
+            writer.add_int(data._gold_bank)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BankReplyServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BarberAgreeServerPacket(Packet):
+    """
+    Purchasing a new hair style
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
     _change: AvatarChange = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class BarberAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BarberAgreeServerPacket): The data to serialize.
         """
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
-        if data._change is None:
-            raise SerializationError("change must be provided.")
-        AvatarChange.serialize(writer, data._change)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+            if data._change is None:
+                raise SerializationError("change must be provided.")
+            AvatarChange.serialize(writer, data._change)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BarberAgreeServerPacket":

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

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

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

@@ -66,12 +66,16 @@ class BigCoords:
             writer (EoWriter): The writer that the data will be serialized to.
             data (BigCoords): The data to serialize.
         """
-        if data._x is None:
-            raise SerializationError("x must be provided.")
-        writer.add_short(data._x)
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_short(data._y)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._x is None:
+                raise SerializationError("x must be provided.")
+            writer.add_short(data._x)
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_short(data._y)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BigCoords":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BoardOpenServerPacket(Packet):
+    """
+    Reply to opening a town board
+    """
     _byte_size: int = 0
     _board_id: int = None # type: ignore [assignment]
     _posts_count: int = None # type: ignore [assignment]
@@ -99,20 +102,25 @@ class BoardOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardOpenServerPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_char(data._board_id)
-        if data._posts_count is None:
-            raise SerializationError("posts_count must be provided.")
-        writer.add_char(data._posts_count)
-        if data._posts is None:
-            raise SerializationError("posts must be provided.")
-        if len(data._posts) > 252:
-            raise SerializationError(f"Expected length of posts to be 252 or less, got {len(data._posts)}.")
-        for i in range(data._posts_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_char(data._board_id)
+            if data._posts_count is None:
+                raise SerializationError("posts_count must be provided.")
+            writer.add_char(data._posts_count)
+            if data._posts is None:
+                raise SerializationError("posts must be provided.")
+            if len(data._posts) > 252:
+                raise SerializationError(f"Expected length of posts to be 252 or less, got {len(data._posts)}.")
+            for i in range(data._posts_count):
+                BoardPostListing.serialize(writer, data._posts[i])
                 writer.add_byte(0xFF)
-            BoardPostListing.serialize(writer, data._posts[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardOpenServerPacket":
@@ -135,8 +143,7 @@ class BoardOpenServerPacket(Packet):
             data._posts = []
             for i in range(data._posts_count):
                 data._posts.append(BoardPostListing.deserialize(reader))
-                if i + 1 < data._posts_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BoardPlayerServerPacket(Packet):
+    """
+    Reply to reading a post on a town board
+    """
     _byte_size: int = 0
     _post_id: int = None # type: ignore [assignment]
     _post_body: str = None # type: ignore [assignment]
@@ -87,12 +90,18 @@ class BoardPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardPlayerServerPacket): The data to serialize.
         """
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
-        if data._post_body is None:
-            raise SerializationError("post_body must be provided.")
-        writer.add_string(data._post_body)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+            if data._post_body is None:
+                raise SerializationError("post_body must be provided.")
+            writer.add_string(data._post_body)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardPlayerServerPacket":

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

@@ -67,17 +67,23 @@ class BoardPostListing:
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardPostListing): The data to serialize.
         """
-        if data._post_id is None:
-            raise SerializationError("post_id must be provided.")
-        writer.add_short(data._post_id)
-        writer.add_byte(0xFF)
-        if data._author is None:
-            raise SerializationError("author must be provided.")
-        writer.add_string(data._author)
-        writer.add_byte(0xFF)
-        if data._subject is None:
-            raise SerializationError("subject must be provided.")
-        writer.add_string(data._subject)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._post_id is None:
+                raise SerializationError("post_id must be provided.")
+            writer.add_short(data._post_id)
+            writer.add_byte(0xFF)
+            if data._author is None:
+                raise SerializationError("author must be provided.")
+            writer.add_string(data._author)
+            writer.add_byte(0xFF)
+            if data._subject is None:
+                raise SerializationError("subject must be provided.")
+            writer.add_string(data._subject)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardPostListing":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BookReplyServerPacket(Packet):
+    """
+    Reply to requesting a book
+    """
     _byte_size: int = 0
     _details: CharacterDetails = None # type: ignore [assignment]
     _icon: CharacterIcon = None # type: ignore [assignment]
@@ -91,19 +94,24 @@ class BookReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BookReplyServerPacket): The data to serialize.
         """
-        if data._details is None:
-            raise SerializationError("details must be provided.")
-        CharacterDetails.serialize(writer, data._details)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_char(int(data._icon))
-        writer.add_byte(0xFF)
-        if data._quest_names is None:
-            raise SerializationError("quest_names must be provided.")
-        for i in range(len(data._quest_names)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._details is None:
+                raise SerializationError("details must be provided.")
+            CharacterDetails.serialize(writer, data._details)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_char(int(data._icon))
+            writer.add_byte(0xFF)
+            if data._quest_names is None:
+                raise SerializationError("quest_names must be provided.")
+            for i in range(len(data._quest_names)):
+                writer.add_string(data._quest_names[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._quest_names[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BookReplyServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CastAcceptServerPacket(Packet):
+    """
+    Nearby NPC killed by player spell and you leveled up
+    """
     _byte_size: int = 0
     _spell_id: int = None # type: ignore [assignment]
     _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
@@ -132,21 +135,25 @@ class CastAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CastAcceptServerPacket): 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._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        if data._caster_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        if data._experience is None:
-            raise SerializationError("experience must be provided.")
-        writer.add_int(data._experience)
-        if data._level_up is None:
-            raise SerializationError("level_up must be provided.")
-        LevelUpStats.serialize(writer, data._level_up)
+        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._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            if data._caster_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            if data._experience is None:
+                raise SerializationError("experience must be provided.")
+            writer.add_int(data._experience)
+            if data._level_up is None:
+                raise SerializationError("level_up must be provided.")
+            LevelUpStats.serialize(writer, data._level_up)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CastAcceptServerPacket":

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

@@ -15,6 +15,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CastReplyServerPacket(Packet):
+    """
+    Nearby NPC hit by a spell from a player
+    """
     _byte_size: int = 0
     _spell_id: int = None # type: ignore [assignment]
     _caster_id: int = None # type: ignore [assignment]
@@ -185,30 +188,34 @@ class CastReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CastReplyServerPacket): The data to serialize.
         """
-        if data._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
-        if data._caster_id is None:
-            raise SerializationError("caster_id must be provided.")
-        writer.add_short(data._caster_id)
-        if data._caster_direction is None:
-            raise SerializationError("caster_direction must be provided.")
-        writer.add_char(int(data._caster_direction))
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_short(data._hp_percentage)
-        if data._caster_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        reached_missing_optional = data._kill_steal_protection is None
-        if not reached_missing_optional:
-            writer.add_char(int(cast(NpcKillStealProtectionState, data._kill_steal_protection)))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._caster_id is None:
+                raise SerializationError("caster_id must be provided.")
+            writer.add_short(data._caster_id)
+            if data._caster_direction is None:
+                raise SerializationError("caster_direction must be provided.")
+            writer.add_char(int(data._caster_direction))
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_short(data._hp_percentage)
+            if data._caster_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            reached_missing_optional = data._kill_steal_protection is None
+            if not reached_missing_optional:
+                writer.add_char(int(cast(NpcKillStealProtectionState, data._kill_steal_protection)))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CastReplyServerPacket":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class CastSpecServerPacket(Packet):
+    """
+    Nearby NPC killed by player spell
+    """
     _byte_size: int = 0
     _spell_id: int = None # type: ignore [assignment]
     _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
@@ -124,18 +127,22 @@ class CastSpecServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (CastSpecServerPacket): 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._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        if data._caster_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        reached_missing_optional = data._experience is None
-        if not reached_missing_optional:
-            writer.add_int(cast(int, data._experience))
+        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._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            if data._caster_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            reached_missing_optional = data._experience is None
+            if not reached_missing_optional:
+                writer.add_int(cast(int, data._experience))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CastSpecServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChairCloseServerPacket(Packet):
+    """
+    Your character standing up from a chair
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class ChairCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChairCloseServerPacket): 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._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._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) -> "ChairCloseServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChairPlayerServerPacket(Packet):
+    """
+    Nearby player sitting on a chair
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -98,15 +101,19 @@ class ChairPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChairPlayerServerPacket): 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._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            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) -> "ChairPlayerServerPacket":

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

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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class ChairReplyServerPacket(Packet):
+    """
+    Your character sitting on a chair
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _coords: Coords = None # type: ignore [assignment]
@@ -98,15 +101,19 @@ class ChairReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ChairReplyServerPacket): 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._coords is None:
-            raise SerializationError("coords must be provided.")
-        Coords.serialize(writer, data._coords)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._coords is None:
+                raise SerializationError("coords must be provided.")
+            Coords.serialize(writer, data._coords)
+            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) -> "ChairReplyServerPacket":