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

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

@@ -144,27 +144,31 @@ class ServerSettings:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ServerSettings): The data to serialize.
         """
-        if data._jail_map is None:
-            raise SerializationError("jail_map must be provided.")
-        writer.add_short(data._jail_map)
-        if data._rescue_map is None:
-            raise SerializationError("rescue_map must be provided.")
-        writer.add_short(data._rescue_map)
-        if data._rescue_coords is None:
-            raise SerializationError("rescue_coords must be provided.")
-        Coords.serialize(writer, data._rescue_coords)
-        if data._spy_and_light_guide_flood_rate is None:
-            raise SerializationError("spy_and_light_guide_flood_rate must be provided.")
-        writer.add_short(data._spy_and_light_guide_flood_rate)
-        if data._guardian_flood_rate is None:
-            raise SerializationError("guardian_flood_rate must be provided.")
-        writer.add_short(data._guardian_flood_rate)
-        if data._game_master_flood_rate is None:
-            raise SerializationError("game_master_flood_rate must be provided.")
-        writer.add_short(data._game_master_flood_rate)
-        if data._high_game_master_flood_rate is None:
-            raise SerializationError("high_game_master_flood_rate must be provided.")
-        writer.add_short(data._high_game_master_flood_rate)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._jail_map is None:
+                raise SerializationError("jail_map must be provided.")
+            writer.add_short(data._jail_map)
+            if data._rescue_map is None:
+                raise SerializationError("rescue_map must be provided.")
+            writer.add_short(data._rescue_map)
+            if data._rescue_coords is None:
+                raise SerializationError("rescue_coords must be provided.")
+            Coords.serialize(writer, data._rescue_coords)
+            if data._spy_and_light_guide_flood_rate is None:
+                raise SerializationError("spy_and_light_guide_flood_rate must be provided.")
+            writer.add_short(data._spy_and_light_guide_flood_rate)
+            if data._guardian_flood_rate is None:
+                raise SerializationError("guardian_flood_rate must be provided.")
+            writer.add_short(data._guardian_flood_rate)
+            if data._game_master_flood_rate is None:
+                raise SerializationError("game_master_flood_rate must be provided.")
+            writer.add_short(data._game_master_flood_rate)
+            if data._high_game_master_flood_rate is None:
+                raise SerializationError("high_game_master_flood_rate must be provided.")
+            writer.add_short(data._high_game_master_flood_rate)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ServerSettings":

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

@@ -101,15 +101,19 @@ class ShopBuyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopBuyServerPacket): 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._bought_item is None:
-            raise SerializationError("bought_item must be provided.")
-        Item.serialize(writer, data._bought_item)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        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._bought_item is None:
+                raise SerializationError("bought_item must be provided.")
+            Item.serialize(writer, data._bought_item)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopBuyServerPacket":

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

@@ -68,15 +68,19 @@ class ShopCraftItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCraftItem): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._ingredients is None:
-            raise SerializationError("ingredients must be provided.")
-        if len(data._ingredients) != 4:
-            raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
-        for i in range(4):
-            CharItem.serialize(writer, data._ingredients[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._ingredients is None:
+                raise SerializationError("ingredients must be provided.")
+            if len(data._ingredients) != 4:
+                raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
+            for i in range(4):
+                CharItem.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCraftItem":

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

@@ -110,18 +110,22 @@ class ShopCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopCreateServerPacket): The data to serialize.
         """
-        if data._craft_item_id is None:
-            raise SerializationError("craft_item_id must be provided.")
-        writer.add_short(data._craft_item_id)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._ingredients is None:
-            raise SerializationError("ingredients must be provided.")
-        if len(data._ingredients) != 4:
-            raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
-        for i in range(4):
-            Item.serialize(writer, data._ingredients[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._craft_item_id is None:
+                raise SerializationError("craft_item_id must be provided.")
+            writer.add_short(data._craft_item_id)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._ingredients is None:
+                raise SerializationError("ingredients must be provided.")
+            if len(data._ingredients) != 4:
+                raise SerializationError(f"Expected length of ingredients to be exactly 4, got {len(data._ingredients)}.")
+            for i in range(4):
+                Item.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopCreateServerPacket":

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

@@ -111,23 +111,29 @@ class ShopOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopOpenServerPacket): 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._shop_name is None:
-            raise SerializationError("shop_name must be provided.")
-        writer.add_string(data._shop_name)
-        writer.add_byte(0xFF)
-        if data._trade_items is None:
-            raise SerializationError("trade_items must be provided.")
-        for i in range(len(data._trade_items)):
-            ShopTradeItem.serialize(writer, data._trade_items[i])
-        writer.add_byte(0xFF)
-        if data._craft_items is None:
-            raise SerializationError("craft_items must be provided.")
-        for i in range(len(data._craft_items)):
-            ShopCraftItem.serialize(writer, data._craft_items[i])
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_short(data._session_id)
+            if data._shop_name is None:
+                raise SerializationError("shop_name must be provided.")
+            writer.add_string(data._shop_name)
+            writer.add_byte(0xFF)
+            if data._trade_items is None:
+                raise SerializationError("trade_items must be provided.")
+            for i in range(len(data._trade_items)):
+                ShopTradeItem.serialize(writer, data._trade_items[i])
+            writer.add_byte(0xFF)
+            if data._craft_items is None:
+                raise SerializationError("craft_items must be provided.")
+            for i in range(len(data._craft_items)):
+                ShopCraftItem.serialize(writer, data._craft_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) -> "ShopOpenServerPacket":

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

@@ -101,15 +101,19 @@ class ShopSellServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopSellServerPacket): The data to serialize.
         """
-        if data._sold_item is None:
-            raise SerializationError("sold_item must be provided.")
-        ShopSoldItem.serialize(writer, data._sold_item)
-        if data._gold_amount is None:
-            raise SerializationError("gold_amount must be provided.")
-        writer.add_int(data._gold_amount)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._sold_item is None:
+                raise SerializationError("sold_item must be provided.")
+            ShopSoldItem.serialize(writer, data._sold_item)
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopSellServerPacket":

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

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

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

@@ -100,18 +100,22 @@ class ShopTradeItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (ShopTradeItem): The data to serialize.
         """
-        if data._item_id is None:
-            raise SerializationError("item_id must be provided.")
-        writer.add_short(data._item_id)
-        if data._buy_price is None:
-            raise SerializationError("buy_price must be provided.")
-        writer.add_three(data._buy_price)
-        if data._sell_price is None:
-            raise SerializationError("sell_price must be provided.")
-        writer.add_three(data._sell_price)
-        if data._max_buy_amount is None:
-            raise SerializationError("max_buy_amount must be provided.")
-        writer.add_char(data._max_buy_amount)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_id is None:
+                raise SerializationError("item_id must be provided.")
+            writer.add_short(data._item_id)
+            if data._buy_price is None:
+                raise SerializationError("buy_price must be provided.")
+            writer.add_three(data._buy_price)
+            if data._sell_price is None:
+                raise SerializationError("sell_price must be provided.")
+            writer.add_three(data._sell_price)
+            if data._max_buy_amount is None:
+                raise SerializationError("max_buy_amount must be provided.")
+            writer.add_char(data._max_buy_amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ShopTradeItem":

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

@@ -91,12 +91,16 @@ class SitCloseServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitCloseServerPacket): 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) -> "SitCloseServerPacket":

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

@@ -101,16 +101,20 @@ class SitPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitPlayerServerPacket): 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))
-        writer.add_char(0)
+        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))
+            writer.add_char(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitPlayerServerPacket":

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

@@ -91,12 +91,16 @@ class SitRemoveServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitRemoveServerPacket): 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) -> "SitRemoveServerPacket":

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

@@ -101,16 +101,20 @@ class SitReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SitReplyServerPacket): 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))
-        writer.add_char(0)
+        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))
+            writer.add_char(0)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SitReplyServerPacket":

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

@@ -130,27 +130,31 @@ class SkillLearn:
             writer (EoWriter): The writer that the data will be serialized to.
             data (SkillLearn): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._level_requirement is None:
-            raise SerializationError("level_requirement must be provided.")
-        writer.add_char(data._level_requirement)
-        if data._class_requirement is None:
-            raise SerializationError("class_requirement must be provided.")
-        writer.add_char(data._class_requirement)
-        if data._cost is None:
-            raise SerializationError("cost must be provided.")
-        writer.add_int(data._cost)
-        if data._skill_requirements is None:
-            raise SerializationError("skill_requirements must be provided.")
-        if len(data._skill_requirements) != 4:
-            raise SerializationError(f"Expected length of skill_requirements to be exactly 4, got {len(data._skill_requirements)}.")
-        for i in range(4):
-            writer.add_short(data._skill_requirements[i])
-        if data._stat_requirements is None:
-            raise SerializationError("stat_requirements must be provided.")
-        CharacterBaseStats.serialize(writer, data._stat_requirements)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._level_requirement is None:
+                raise SerializationError("level_requirement must be provided.")
+            writer.add_char(data._level_requirement)
+            if data._class_requirement is None:
+                raise SerializationError("class_requirement must be provided.")
+            writer.add_char(data._class_requirement)
+            if data._cost is None:
+                raise SerializationError("cost must be provided.")
+            writer.add_int(data._cost)
+            if data._skill_requirements is None:
+                raise SerializationError("skill_requirements must be provided.")
+            if len(data._skill_requirements) != 4:
+                raise SerializationError(f"Expected length of skill_requirements to be exactly 4, got {len(data._skill_requirements)}.")
+            for i in range(4):
+                writer.add_short(data._skill_requirements[i])
+            if data._stat_requirements is None:
+                raise SerializationError("stat_requirements must be provided.")
+            CharacterBaseStats.serialize(writer, data._stat_requirements)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SkillLearn":

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

@@ -63,9 +63,11 @@ class SpellErrorServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellErrorServerPacket): 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_byte(255)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellErrorServerPacket":
@@ -82,8 +84,7 @@ class SpellErrorServerPacket(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_byte()
+            reader.get_byte()
             data._byte_size = reader.position - reader_start_position
             return data
         finally:

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

@@ -91,12 +91,16 @@ class SpellPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellPlayerServerPacket): 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))
+        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))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellPlayerServerPacket":

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

@@ -98,12 +98,16 @@ class SpellRequestServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellRequestServerPacket): 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._spell_id is None:
-            raise SerializationError("spell_id must be provided.")
-        writer.add_short(data._spell_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellRequestServerPacket":

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

@@ -143,22 +143,26 @@ class SpellTargetGroupServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellTargetGroupServerPacket): 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_tp is None:
-            raise SerializationError("caster_tp must be provided.")
-        writer.add_short(data._caster_tp)
-        if data._spell_heal_hp is None:
-            raise SerializationError("spell_heal_hp must be provided.")
-        writer.add_short(data._spell_heal_hp)
-        if data._players is None:
-            raise SerializationError("players must be provided.")
-        for i in range(len(data._players)):
-            GroupHealTargetPlayer.serialize(writer, data._players[i])
+        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_tp is None:
+                raise SerializationError("caster_tp must be provided.")
+            writer.add_short(data._caster_tp)
+            if data._spell_heal_hp is None:
+                raise SerializationError("spell_heal_hp must be provided.")
+            writer.add_short(data._spell_heal_hp)
+            if data._players is None:
+                raise SerializationError("players must be provided.")
+            for i in range(len(data._players)):
+                GroupHealTargetPlayer.serialize(writer, data._players[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellTargetGroupServerPacket":