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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class PriestRequestServerPacket(Packet):
+    """
+    Wedding request
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _partner_name: str = None # type: ignore [assignment]
@@ -87,12 +90,16 @@ class PriestRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (PriestRequestServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._partner_name is None:
-            raise SerializationError("partner_name must be provided.")
-        writer.add_string(data._partner_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_short(data._session_id)
+            if data._partner_name is None:
+                raise SerializationError("partner_name must be provided.")
+            writer.add_string(data._partner_name)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PriestRequestServerPacket":

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

@@ -58,12 +58,16 @@ class PubFile:
             writer (EoWriter): The writer that the data will be serialized to.
             data (PubFile): The data to serialize.
         """
-        if data._file_id is None:
-            raise SerializationError("file_id must be provided.")
-        writer.add_char(data._file_id)
-        if data._content is None:
-            raise SerializationError("content must be provided.")
-        writer.add_bytes(data._content)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._file_id is None:
+                raise SerializationError("file_id must be provided.")
+            writer.add_char(data._file_id)
+            if data._content is None:
+                raise SerializationError("content must be provided.")
+            writer.add_bytes(data._content)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "PubFile":

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

@@ -14,6 +14,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class QuestDialogServerPacket(Packet):
+    """
+    Quest selection dialog
+    """
     _byte_size: int = 0
     _quest_count: int = None # type: ignore [assignment]
     _behavior_id: int = None # type: ignore [assignment]
@@ -160,36 +163,40 @@ class QuestDialogServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestDialogServerPacket): The data to serialize.
         """
-        if data._quest_count is None:
-            raise SerializationError("quest_count must be provided.")
-        writer.add_char(data._quest_count)
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
-        if data._quest_id is None:
-            raise SerializationError("quest_id must be provided.")
-        writer.add_short(data._quest_id)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        if data._dialog_id is None:
-            raise SerializationError("dialog_id must be provided.")
-        writer.add_short(data._dialog_id)
-        writer.add_byte(0xFF)
-        if data._quest_entries is None:
-            raise SerializationError("quest_entries must be provided.")
-        if len(data._quest_entries) > 252:
-            raise SerializationError(f"Expected length of quest_entries to be 252 or less, got {len(data._quest_entries)}.")
-        for i in range(data._quest_count):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._quest_count is None:
+                raise SerializationError("quest_count must be provided.")
+            writer.add_char(data._quest_count)
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+            if data._quest_id is None:
+                raise SerializationError("quest_id must be provided.")
+            writer.add_short(data._quest_id)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._dialog_id is None:
+                raise SerializationError("dialog_id must be provided.")
+            writer.add_short(data._dialog_id)
+            writer.add_byte(0xFF)
+            if data._quest_entries is None:
+                raise SerializationError("quest_entries must be provided.")
+            if len(data._quest_entries) > 252:
+                raise SerializationError(f"Expected length of quest_entries to be 252 or less, got {len(data._quest_entries)}.")
+            for i in range(data._quest_count):
+                DialogQuestEntry.serialize(writer, data._quest_entries[i])
                 writer.add_byte(0xFF)
-            DialogQuestEntry.serialize(writer, data._quest_entries[i])
-        if data._dialog_entries is None:
-            raise SerializationError("dialog_entries must be provided.")
-        for i in range(len(data._dialog_entries)):
-            if i > 0:
+            if data._dialog_entries is None:
+                raise SerializationError("dialog_entries must be provided.")
+            for i in range(len(data._dialog_entries)):
+                DialogEntry.serialize(writer, data._dialog_entries[i])
                 writer.add_byte(0xFF)
-            DialogEntry.serialize(writer, data._dialog_entries[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestDialogServerPacket":
@@ -216,8 +223,7 @@ class QuestDialogServerPacket(Packet):
             data._quest_entries = []
             for i in range(data._quest_count):
                 data._quest_entries.append(DialogQuestEntry.deserialize(reader))
-                if i + 1 < data._quest_count:
-                    reader.next_chunk()
+                reader.next_chunk()
             data._dialog_entries = []
             while reader.remaining > 0:
                 data._dialog_entries.append(DialogEntry.deserialize(reader))

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

@@ -15,6 +15,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class QuestListServerPacket(Packet):
+    """
+    Quest history / progress reply
+    """
     _byte_size: int = 0
     _page: QuestPage = None # type: ignore [assignment]
     _quests_count: int = None # type: ignore [assignment]
@@ -103,20 +106,26 @@ class QuestListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestListServerPacket): The data to serialize.
         """
-        if data._page is None:
-            raise SerializationError("page must be provided.")
-        writer.add_char(int(data._page))
-        if data._quests_count is None:
-            raise SerializationError("quests_count must be provided.")
-        writer.add_short(data._quests_count)
-        if data._page == QuestPage.Progress:
-            if not isinstance(data._page_data, QuestListServerPacket.PageDataProgress):
-                raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataProgress for page " + QuestPage(data._page).name + ".")
-            QuestListServerPacket.PageDataProgress.serialize(writer, data._page_data)
-        elif data._page == QuestPage.History:
-            if not isinstance(data._page_data, QuestListServerPacket.PageDataHistory):
-                raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataHistory for page " + QuestPage(data._page).name + ".")
-            QuestListServerPacket.PageDataHistory.serialize(writer, data._page_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._page is None:
+                raise SerializationError("page must be provided.")
+            writer.add_char(int(data._page))
+            if data._quests_count is None:
+                raise SerializationError("quests_count must be provided.")
+            writer.add_short(data._quests_count)
+            if data._page == QuestPage.Progress:
+                if not isinstance(data._page_data, QuestListServerPacket.PageDataProgress):
+                    raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataProgress for page " + QuestPage(data._page).name + ".")
+                QuestListServerPacket.PageDataProgress.serialize(writer, data._page_data)
+            elif data._page == QuestPage.History:
+                if not isinstance(data._page_data, QuestListServerPacket.PageDataHistory):
+                    raise SerializationError("Expected page_data to be type QuestListServerPacket.PageDataHistory for page " + QuestPage(data._page).name + ".")
+                QuestListServerPacket.PageDataHistory.serialize(writer, data._page_data)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestListServerPacket":
@@ -150,10 +159,9 @@ class QuestListServerPacket(Packet):
         return f"QuestListServerPacket(byte_size={repr(self._byte_size)}, page={repr(self._page)}, quests_count={repr(self._quests_count)}, page_data={repr(self._page_data)})"
 
     PageData = Union['QuestListServerPacket.PageDataProgress', 'QuestListServerPacket.PageDataHistory', None]
-    PageData.__doc__ = \
-        """
-        Data associated with different values of the `page` field.
-        """
+    """
+    Data associated with different values of the `page` field.
+    """
 
     class PageDataProgress:
         """
@@ -189,12 +197,15 @@ class QuestListServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (QuestListServerPacket.PageDataProgress): The data to serialize.
             """
-            if data._quest_progress_entries is None:
-                raise SerializationError("quest_progress_entries must be provided.")
-            for i in range(len(data._quest_progress_entries)):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._quest_progress_entries is None:
+                    raise SerializationError("quest_progress_entries must be provided.")
+                for i in range(len(data._quest_progress_entries)):
+                    QuestProgressEntry.serialize(writer, data._quest_progress_entries[i])
                     writer.add_byte(0xFF)
-                QuestProgressEntry.serialize(writer, data._quest_progress_entries[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "QuestListServerPacket.PageDataProgress":
@@ -257,12 +268,15 @@ class QuestListServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (QuestListServerPacket.PageDataHistory): The data to serialize.
             """
-            if data._completed_quests is None:
-                raise SerializationError("completed_quests must be provided.")
-            for i in range(len(data._completed_quests)):
-                if i > 0:
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._completed_quests is None:
+                    raise SerializationError("completed_quests must be provided.")
+                for i in range(len(data._completed_quests)):
+                    writer.add_string(data._completed_quests[i])
                     writer.add_byte(0xFF)
-                writer.add_string(data._completed_quests[i])
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "QuestListServerPacket.PageDataHistory":

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

@@ -94,23 +94,29 @@ class QuestProgressEntry:
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestProgressEntry): The data to serialize.
         """
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._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)
-        if data._icon is None:
-            raise SerializationError("icon must be provided.")
-        writer.add_short(int(data._icon))
-        if data._progress is None:
-            raise SerializationError("progress must be provided.")
-        writer.add_short(data._progress)
-        if data._target is None:
-            raise SerializationError("target must be provided.")
-        writer.add_short(data._target)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._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)
+            if data._icon is None:
+                raise SerializationError("icon must be provided.")
+            writer.add_short(int(data._icon))
+            if data._progress is None:
+                raise SerializationError("progress must be provided.")
+            writer.add_short(data._progress)
+            if data._target is None:
+                raise SerializationError("target must be provided.")
+            writer.add_short(data._target)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "QuestProgressEntry":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class QuestReportServerPacket(Packet):
+    """
+    NPC chat messages
+    """
     _byte_size: int = 0
     _npc_id: int = None # type: ignore [assignment]
     _messages: list[str] = None # type: ignore [assignment]
@@ -88,16 +91,21 @@ class QuestReportServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (QuestReportServerPacket): The data to serialize.
         """
-        if data._npc_id is None:
-            raise SerializationError("npc_id must be provided.")
-        writer.add_short(data._npc_id)
-        writer.add_byte(0xFF)
-        if data._messages is None:
-            raise SerializationError("messages must be provided.")
-        for i in range(len(data._messages)):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._npc_id is None:
+                raise SerializationError("npc_id must be provided.")
+            writer.add_short(data._npc_id)
+            writer.add_byte(0xFF)
+            if data._messages is None:
+                raise SerializationError("messages must be provided.")
+            for i in range(len(data._messages)):
+                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) -> "QuestReportServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RangeReplyServerPacket(Packet):
+    """
+    Reply to request for information about nearby players and NPCs
+    """
     _byte_size: int = 0
     _nearby: NearbyInfo = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class RangeReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RangeReplyServerPacket): The data to serialize.
         """
-        if data._nearby is None:
-            raise SerializationError("nearby must be provided.")
-        NearbyInfo.serialize(writer, data._nearby)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._nearby is None:
+                raise SerializationError("nearby must be provided.")
+            NearbyInfo.serialize(writer, data._nearby)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RangeReplyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RecoverAgreeServerPacket(Packet):
+    """
+    Nearby player gained HP
+    """
     _byte_size: int = 0
     _player_id: int = None # type: ignore [assignment]
     _heal_hp: int = None # type: ignore [assignment]
@@ -112,15 +115,19 @@ class RecoverAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverAgreeServerPacket): 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._heal_hp is None:
-            raise SerializationError("heal_hp must be provided.")
-        writer.add_int(data._heal_hp)
-        if data._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
+        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._heal_hp is None:
+                raise SerializationError("heal_hp must be provided.")
+            writer.add_int(data._heal_hp)
+            if data._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverAgreeServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RecoverListServerPacket(Packet):
+    """
+    Stats update
+    """
     _byte_size: int = 0
     _class_id: int = None # type: ignore [assignment]
     _stats: CharacterStatsUpdate = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class RecoverListServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverListServerPacket): The data to serialize.
         """
-        if data._class_id is None:
-            raise SerializationError("class_id must be provided.")
-        writer.add_short(data._class_id)
-        if data._stats is None:
-            raise SerializationError("stats must be provided.")
-        CharacterStatsUpdate.serialize(writer, data._stats)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._class_id is None:
+                raise SerializationError("class_id must be provided.")
+            writer.add_short(data._class_id)
+            if data._stats is None:
+                raise SerializationError("stats must be provided.")
+            CharacterStatsUpdate.serialize(writer, data._stats)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverListServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RecoverPlayerServerPacket(Packet):
+    """
+    HP/TP update
+    """
     _byte_size: int = 0
     _hp: int = None # type: ignore [assignment]
     _tp: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class RecoverPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverPlayerServerPacket): The data to serialize.
         """
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverPlayerServerPacket":

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

@@ -13,6 +13,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RecoverReplyServerPacket(Packet):
+    """
+    Karma/experience update
+    """
     _byte_size: int = 0
     _experience: int = None # type: ignore [assignment]
     _karma: int = None # type: ignore [assignment]
@@ -65,7 +68,7 @@ class RecoverReplyServerPacket(Packet):
     @property
     def level_up(self) -> Optional[int]:
         """
-        A value greater than 0 is "new level" and indicates the player leveled up.
+        A value greater than 0 is "new level" and indicates the player leveled up.
         The official client reads this if the packet is larger than 6 bytes.
 
         Note:
@@ -76,7 +79,7 @@ class RecoverReplyServerPacket(Packet):
     @level_up.setter
     def level_up(self, level_up: Optional[int]) -> None:
         """
-        A value greater than 0 is "new level" and indicates the player leveled up.
+        A value greater than 0 is "new level" and indicates the player leveled up.
         The official client reads this if the packet is larger than 6 bytes.
 
         Note:
@@ -162,21 +165,25 @@ class RecoverReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverReplyServerPacket): The data to serialize.
         """
-        if data._experience is None:
-            raise SerializationError("experience must be provided.")
-        writer.add_int(data._experience)
-        if data._karma is None:
-            raise SerializationError("karma must be provided.")
-        writer.add_short(data._karma)
-        reached_missing_optional = data._level_up is None
-        if not reached_missing_optional:
-            writer.add_char(cast(int, data._level_up))
-        reached_missing_optional = reached_missing_optional or data._stat_points is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._stat_points))
-        reached_missing_optional = reached_missing_optional or data._skill_points is None
-        if not reached_missing_optional:
-            writer.add_short(cast(int, data._skill_points))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._experience is None:
+                raise SerializationError("experience must be provided.")
+            writer.add_int(data._experience)
+            if data._karma is None:
+                raise SerializationError("karma must be provided.")
+            writer.add_short(data._karma)
+            reached_missing_optional = data._level_up is None
+            if not reached_missing_optional:
+                writer.add_char(cast(int, data._level_up))
+            reached_missing_optional = reached_missing_optional or data._stat_points is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._stat_points))
+            reached_missing_optional = reached_missing_optional or data._skill_points is None
+            if not reached_missing_optional:
+                writer.add_short(cast(int, data._skill_points))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverReplyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RecoverTargetGroupServerPacket(Packet):
+    """
+    Updated stats when levelling up from party experience
+    """
     _byte_size: int = 0
     _stat_points: int = None # type: ignore [assignment]
     _skill_points: int = None # type: ignore [assignment]
@@ -146,21 +149,25 @@ class RecoverTargetGroupServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RecoverTargetGroupServerPacket): The data to serialize.
         """
-        if data._stat_points is None:
-            raise SerializationError("stat_points must be provided.")
-        writer.add_short(data._stat_points)
-        if data._skill_points is None:
-            raise SerializationError("skill_points must be provided.")
-        writer.add_short(data._skill_points)
-        if data._max_hp is None:
-            raise SerializationError("max_hp must be provided.")
-        writer.add_short(data._max_hp)
-        if data._max_tp is None:
-            raise SerializationError("max_tp must be provided.")
-        writer.add_short(data._max_tp)
-        if data._max_sp is None:
-            raise SerializationError("max_sp must be provided.")
-        writer.add_short(data._max_sp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._stat_points is None:
+                raise SerializationError("stat_points must be provided.")
+            writer.add_short(data._stat_points)
+            if data._skill_points is None:
+                raise SerializationError("skill_points must be provided.")
+            writer.add_short(data._skill_points)
+            if data._max_hp is None:
+                raise SerializationError("max_hp must be provided.")
+            writer.add_short(data._max_hp)
+            if data._max_tp is None:
+                raise SerializationError("max_tp must be provided.")
+            writer.add_short(data._max_tp)
+            if data._max_sp is None:
+                raise SerializationError("max_sp must be provided.")
+            writer.add_short(data._max_sp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RecoverTargetGroupServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class RefreshReplyServerPacket(Packet):
+    """
+    Reply to request for new info about nearby objects
+    """
     _byte_size: int = 0
     _nearby: NearbyInfo = None # type: ignore [assignment]
 
@@ -71,9 +74,13 @@ class RefreshReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (RefreshReplyServerPacket): The data to serialize.
         """
-        if data._nearby is None:
-            raise SerializationError("nearby must be provided.")
-        NearbyInfo.serialize(writer, data._nearby)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._nearby is None:
+                raise SerializationError("nearby must be provided.")
+            NearbyInfo.serialize(writer, data._nearby)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "RefreshReplyServerPacket":