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

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class MarriageReplyServerPacket(Packet):
+    """
+    Reply to client Marriage-family packets
+    """
     _byte_size: int = 0
     _reply_code: MarriageReply = None # type: ignore [assignment]
     _reply_code_data: 'MarriageReplyServerPacket.ReplyCodeData' = None
@@ -84,13 +87,17 @@ class MarriageReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MarriageReplyServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_short(int(data._reply_code))
-        if data._reply_code == MarriageReply.Success:
-            if not isinstance(data._reply_code_data, MarriageReplyServerPacket.ReplyCodeDataSuccess):
-                raise SerializationError("Expected reply_code_data to be type MarriageReplyServerPacket.ReplyCodeDataSuccess for reply_code " + MarriageReply(data._reply_code).name + ".")
-            MarriageReplyServerPacket.ReplyCodeDataSuccess.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_short(int(data._reply_code))
+            if data._reply_code == MarriageReply.Success:
+                if not isinstance(data._reply_code_data, MarriageReplyServerPacket.ReplyCodeDataSuccess):
+                    raise SerializationError("Expected reply_code_data to be type MarriageReplyServerPacket.ReplyCodeDataSuccess for reply_code " + MarriageReply(data._reply_code).name + ".")
+                MarriageReplyServerPacket.ReplyCodeDataSuccess.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MarriageReplyServerPacket":
@@ -119,10 +126,9 @@ class MarriageReplyServerPacket(Packet):
         return f"MarriageReplyServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['MarriageReplyServerPacket.ReplyCodeDataSuccess', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataSuccess:
         """
@@ -166,9 +172,13 @@ class MarriageReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (MarriageReplyServerPacket.ReplyCodeDataSuccess): The data to serialize.
             """
-            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._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) -> "MarriageReplyServerPacket.ReplyCodeDataSuccess":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class MessageAcceptServerPacket(Packet):
+    """
+    Large message box
+    """
     _byte_size: int = 0
     _messages: list[str] = None # type: ignore [assignment]
 
@@ -79,14 +82,19 @@ class MessageAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageAcceptServerPacket): The data to serialize.
         """
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        if len(data._messages) != 4:
-            raise SerializationError(f"Expected length of messages to be exactly 4, got {len(data._messages)}.")
-        for i in range(4):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            if len(data._messages) != 4:
+                raise SerializationError(f"Expected length of messages to be exactly 4, got {len(data._messages)}.")
+            for i in range(4):
+                writer.add_string(data._messages[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._messages[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessageAcceptServerPacket":
@@ -107,8 +115,7 @@ class MessageAcceptServerPacket(Packet):
             data._messages = []
             for i in range(4):
                 data._messages.append(reader.get_string())
-                if i + 1 < 4:
-                    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/message_close_server_packet.py

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class MessageCloseServerPacket(Packet):
+    """
+    Server is rebooting
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class MessageCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessageCloseServerPacket): 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("r")
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessageCloseServerPacket":
@@ -79,8 +84,7 @@ class MessageCloseServerPacket(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/message_open_server_packet.py

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

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class MessagePongServerPacket(Packet):
+    """
+    #ping command reply
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class MessagePongServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (MessagePongServerPacket): 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_short(2)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MessagePongServerPacket":
@@ -79,8 +84,7 @@ class MessagePongServerPacket(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_short()
+            reader.get_short()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

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

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

@@ -73,27 +73,32 @@ class NearbyInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NearbyInfo): The data to serialize.
         """
-        if data._characters_count is None:
-            raise SerializationError("characters_count must be provided.")
-        writer.add_char(data._characters_count)
-        writer.add_byte(0xFF)
-        if data._characters is None:
-            raise SerializationError("characters must be provided.")
-        if len(data._characters) > 252:
-            raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
-        for i in range(data._characters_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._characters_count is None:
+                raise SerializationError("characters_count must be provided.")
+            writer.add_char(data._characters_count)
+            writer.string_sanitization_mode = True
+            writer.add_byte(0xFF)
+            if data._characters is None:
+                raise SerializationError("characters must be provided.")
+            if len(data._characters) > 252:
+                raise SerializationError(f"Expected length of characters to be 252 or less, got {len(data._characters)}.")
+            for i in range(data._characters_count):
+                CharacterMapInfo.serialize(writer, data._characters[i])
                 writer.add_byte(0xFF)
-            CharacterMapInfo.serialize(writer, data._characters[i])
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        for i in range(len(data._npcs)):
-            NpcMapInfo.serialize(writer, data._npcs[i])
-        writer.add_byte(0xFF)
-        if data._items is None:
-            raise SerializationError("items must be provided.")
-        for i in range(len(data._items)):
-            ItemMapInfo.serialize(writer, data._items[i])
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            for i in range(len(data._npcs)):
+                NpcMapInfo.serialize(writer, data._npcs[i])
+            writer.add_byte(0xFF)
+            if data._items is None:
+                raise SerializationError("items must be provided.")
+            for i in range(len(data._items)):
+                ItemMapInfo.serialize(writer, data._items[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NearbyInfo":
@@ -116,8 +121,7 @@ class NearbyInfo:
             data._characters = []
             for i in range(data._characters_count):
                 data._characters.append(CharacterMapInfo.deserialize(reader))
-                if i + 1 < data._characters_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             npcs_length = int(reader.remaining / 6)
             data._npcs = []
             for i in range(npcs_length):

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class NpcAcceptServerPacket(Packet):
+    """
+    Nearby NPC killed by player and you leveled up
+    """
     _byte_size: int = 0
     _npc_killed_data: NpcKilledData = None # type: ignore [assignment]
     _experience: int = None # type: ignore [assignment]
@@ -98,15 +101,19 @@ class NpcAcceptServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcAcceptServerPacket): The data to serialize.
         """
-        if data._npc_killed_data is None:
-            raise SerializationError("npc_killed_data must be provided.")
-        NpcKilledData.serialize(writer, data._npc_killed_data)
-        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._npc_killed_data is None:
+                raise SerializationError("npc_killed_data must be provided.")
+            NpcKilledData.serialize(writer, data._npc_killed_data)
+            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) -> "NpcAcceptServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class NpcAgreeServerPacket(Packet):
+    """
+    Reply to request for information about nearby NPCs
+    """
     _byte_size: int = 0
     _npcs_count: int = None # type: ignore [assignment]
     _npcs: list[NpcMapInfo] = None # type: ignore [assignment]
@@ -31,7 +34,7 @@ class NpcAgreeServerPacket(Packet):
     def npcs(self) -> list[NpcMapInfo]:
         """
         Note:
-          - Length must be 64008 or less.
+          - Length must be 252 or less.
         """
         return self._npcs
 
@@ -39,7 +42,7 @@ class NpcAgreeServerPacket(Packet):
     def npcs(self, npcs: list[NpcMapInfo]) -> None:
         """
         Note:
-          - Length must be 64008 or less.
+          - Length must be 252 or less.
         """
         self._npcs = npcs
         self._npcs_count = len(self._npcs)
@@ -82,15 +85,19 @@ class NpcAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcAgreeServerPacket): The data to serialize.
         """
-        if data._npcs_count is None:
-            raise SerializationError("npcs_count must be provided.")
-        writer.add_short(data._npcs_count)
-        if data._npcs is None:
-            raise SerializationError("npcs must be provided.")
-        if len(data._npcs) > 64008:
-            raise SerializationError(f"Expected length of npcs to be 64008 or less, got {len(data._npcs)}.")
-        for i in range(data._npcs_count):
-            NpcMapInfo.serialize(writer, data._npcs[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npcs_count is None:
+                raise SerializationError("npcs_count must be provided.")
+            writer.add_char(data._npcs_count)
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            if len(data._npcs) > 252:
+                raise SerializationError(f"Expected length of npcs to be 252 or less, got {len(data._npcs)}.")
+            for i in range(data._npcs_count):
+                NpcMapInfo.serialize(writer, data._npcs[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcAgreeServerPacket":
@@ -107,7 +114,7 @@ class NpcAgreeServerPacket(Packet):
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._npcs_count = reader.get_short()
+            data._npcs_count = reader.get_char()
             data._npcs = []
             for i in range(data._npcs_count):
                 data._npcs.append(NpcMapInfo.deserialize(reader))

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class NpcDialogServerPacket(Packet):
+    """
+    NPC chat message
+    """
     _byte_size: int = 0
     _npc_index: int = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -87,12 +90,16 @@ class NpcDialogServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcDialogServerPacket): 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._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._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            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) -> "NpcDialogServerPacket":

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

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

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

@@ -154,30 +154,34 @@ class NpcKilledData:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcKilledData): The data to serialize.
         """
-        if data._killer_id is None:
-            raise SerializationError("killer_id must be provided.")
-        writer.add_short(data._killer_id)
-        if data._killer_direction is None:
-            raise SerializationError("killer_direction must be provided.")
-        writer.add_char(int(data._killer_direction))
-        if data._npc_index is None:
-            raise SerializationError("npc_index must be provided.")
-        writer.add_short(data._npc_index)
-        if data._drop_index is None:
-            raise SerializationError("drop_index must be provided.")
-        writer.add_short(data._drop_index)
-        if data._drop_id is None:
-            raise SerializationError("drop_id must be provided.")
-        writer.add_short(data._drop_id)
-        if data._drop_coords is None:
-            raise SerializationError("drop_coords must be provided.")
-        Coords.serialize(writer, data._drop_coords)
-        if data._drop_amount is None:
-            raise SerializationError("drop_amount must be provided.")
-        writer.add_int(data._drop_amount)
-        if data._damage is None:
-            raise SerializationError("damage must be provided.")
-        writer.add_three(data._damage)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._killer_id is None:
+                raise SerializationError("killer_id must be provided.")
+            writer.add_short(data._killer_id)
+            if data._killer_direction is None:
+                raise SerializationError("killer_direction must be provided.")
+            writer.add_char(int(data._killer_direction))
+            if data._npc_index is None:
+                raise SerializationError("npc_index must be provided.")
+            writer.add_short(data._npc_index)
+            if data._drop_index is None:
+                raise SerializationError("drop_index must be provided.")
+            writer.add_short(data._drop_index)
+            if data._drop_id is None:
+                raise SerializationError("drop_id must be provided.")
+            writer.add_short(data._drop_id)
+            if data._drop_coords is None:
+                raise SerializationError("drop_coords must be provided.")
+            Coords.serialize(writer, data._drop_coords)
+            if data._drop_amount is None:
+                raise SerializationError("drop_amount must be provided.")
+            writer.add_int(data._drop_amount)
+            if data._damage is None:
+                raise SerializationError("damage must be provided.")
+            writer.add_three(data._damage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcKilledData":

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

@@ -86,18 +86,22 @@ class NpcMapInfo:
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcMapInfo): The data to serialize.
         """
-        if data._index is None:
-            raise SerializationError("index must be provided.")
-        writer.add_char(data._index)
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._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._index is None:
+                raise SerializationError("index must be provided.")
+            writer.add_char(data._index)
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._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) -> "NpcMapInfo":

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

@@ -17,6 +17,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class NpcPlayerServerPacket(Packet):
+    """
+    Main NPC update message
+    """
     _byte_size: int = 0
     _positions: list[NpcUpdatePosition] = None # type: ignore [assignment]
     _attacks: list[NpcUpdateAttack] = None # type: ignore [assignment]
@@ -128,27 +131,33 @@ class NpcPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (NpcPlayerServerPacket): The data to serialize.
         """
-        if data._positions is None:
-            raise SerializationError("positions must be provided.")
-        for i in range(len(data._positions)):
-            NpcUpdatePosition.serialize(writer, data._positions[i])
-        writer.add_byte(0xFF)
-        if data._attacks is None:
-            raise SerializationError("attacks must be provided.")
-        for i in range(len(data._attacks)):
-            NpcUpdateAttack.serialize(writer, data._attacks[i])
-        writer.add_byte(0xFF)
-        if data._chats is None:
-            raise SerializationError("chats must be provided.")
-        for i in range(len(data._chats)):
-            NpcUpdateChat.serialize(writer, data._chats[i])
-        writer.add_byte(0xFF)
-        reached_missing_optional = data._hp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._hp))
-        reached_missing_optional = reached_missing_optional or data._tp is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._tp))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._positions is None:
+                raise SerializationError("positions must be provided.")
+            for i in range(len(data._positions)):
+                NpcUpdatePosition.serialize(writer, data._positions[i])
+            writer.add_byte(0xFF)
+            if data._attacks is None:
+                raise SerializationError("attacks must be provided.")
+            for i in range(len(data._attacks)):
+                NpcUpdateAttack.serialize(writer, data._attacks[i])
+            writer.add_byte(0xFF)
+            if data._chats is None:
+                raise SerializationError("chats must be provided.")
+            for i in range(len(data._chats)):
+                NpcUpdateChat.serialize(writer, data._chats[i])
+            writer.add_byte(0xFF)
+            reached_missing_optional = data._hp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._hp))
+            reached_missing_optional = reached_missing_optional or data._tp is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._tp))
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "NpcPlayerServerPacket":