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

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

@@ -11,7 +11,7 @@ from .....data.eo_reader import EoReader
 class EquipmentPaperdoll:
     """
     Player equipment data.
-    Sent with information about a player's paperdoll.
+    Sent with information about a player's paperdoll.
     Note that these values are item IDs.
     """
     _byte_size: int = 0
@@ -245,51 +245,55 @@ class EquipmentPaperdoll:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EquipmentPaperdoll): The data to serialize.
         """
-        if data._boots is None:
-            raise SerializationError("boots must be provided.")
-        writer.add_short(data._boots)
-        if data._accessory is None:
-            raise SerializationError("accessory must be provided.")
-        writer.add_short(data._accessory)
-        if data._gloves is None:
-            raise SerializationError("gloves must be provided.")
-        writer.add_short(data._gloves)
-        if data._belt is None:
-            raise SerializationError("belt must be provided.")
-        writer.add_short(data._belt)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._necklace is None:
-            raise SerializationError("necklace must be provided.")
-        writer.add_short(data._necklace)
-        if data._hat is None:
-            raise SerializationError("hat must be provided.")
-        writer.add_short(data._hat)
-        if data._shield is None:
-            raise SerializationError("shield must be provided.")
-        writer.add_short(data._shield)
-        if data._weapon is None:
-            raise SerializationError("weapon must be provided.")
-        writer.add_short(data._weapon)
-        if data._ring is None:
-            raise SerializationError("ring must be provided.")
-        if len(data._ring) != 2:
-            raise SerializationError(f"Expected length of ring to be exactly 2, got {len(data._ring)}.")
-        for i in range(2):
-            writer.add_short(data._ring[i])
-        if data._armlet is None:
-            raise SerializationError("armlet must be provided.")
-        if len(data._armlet) != 2:
-            raise SerializationError(f"Expected length of armlet to be exactly 2, got {len(data._armlet)}.")
-        for i in range(2):
-            writer.add_short(data._armlet[i])
-        if data._bracer is None:
-            raise SerializationError("bracer must be provided.")
-        if len(data._bracer) != 2:
-            raise SerializationError(f"Expected length of bracer to be exactly 2, got {len(data._bracer)}.")
-        for i in range(2):
-            writer.add_short(data._bracer[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._boots is None:
+                raise SerializationError("boots must be provided.")
+            writer.add_short(data._boots)
+            if data._accessory is None:
+                raise SerializationError("accessory must be provided.")
+            writer.add_short(data._accessory)
+            if data._gloves is None:
+                raise SerializationError("gloves must be provided.")
+            writer.add_short(data._gloves)
+            if data._belt is None:
+                raise SerializationError("belt must be provided.")
+            writer.add_short(data._belt)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._necklace is None:
+                raise SerializationError("necklace must be provided.")
+            writer.add_short(data._necklace)
+            if data._hat is None:
+                raise SerializationError("hat must be provided.")
+            writer.add_short(data._hat)
+            if data._shield is None:
+                raise SerializationError("shield must be provided.")
+            writer.add_short(data._shield)
+            if data._weapon is None:
+                raise SerializationError("weapon must be provided.")
+            writer.add_short(data._weapon)
+            if data._ring is None:
+                raise SerializationError("ring must be provided.")
+            if len(data._ring) != 2:
+                raise SerializationError(f"Expected length of ring to be exactly 2, got {len(data._ring)}.")
+            for i in range(2):
+                writer.add_short(data._ring[i])
+            if data._armlet is None:
+                raise SerializationError("armlet must be provided.")
+            if len(data._armlet) != 2:
+                raise SerializationError(f"Expected length of armlet to be exactly 2, got {len(data._armlet)}.")
+            for i in range(2):
+                writer.add_short(data._armlet[i])
+            if data._bracer is None:
+                raise SerializationError("bracer must be provided.")
+            if len(data._bracer) != 2:
+                raise SerializationError(f"Expected length of bracer to be exactly 2, got {len(data._bracer)}.")
+            for i in range(2):
+                writer.add_short(data._bracer[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EquipmentPaperdoll":

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

@@ -245,51 +245,55 @@ class EquipmentWelcome:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EquipmentWelcome): The data to serialize.
         """
-        if data._boots is None:
-            raise SerializationError("boots must be provided.")
-        writer.add_short(data._boots)
-        if data._gloves is None:
-            raise SerializationError("gloves must be provided.")
-        writer.add_short(data._gloves)
-        if data._accessory is None:
-            raise SerializationError("accessory must be provided.")
-        writer.add_short(data._accessory)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._belt is None:
-            raise SerializationError("belt must be provided.")
-        writer.add_short(data._belt)
-        if data._necklace is None:
-            raise SerializationError("necklace must be provided.")
-        writer.add_short(data._necklace)
-        if data._hat is None:
-            raise SerializationError("hat must be provided.")
-        writer.add_short(data._hat)
-        if data._shield is None:
-            raise SerializationError("shield must be provided.")
-        writer.add_short(data._shield)
-        if data._weapon is None:
-            raise SerializationError("weapon must be provided.")
-        writer.add_short(data._weapon)
-        if data._ring is None:
-            raise SerializationError("ring must be provided.")
-        if len(data._ring) != 2:
-            raise SerializationError(f"Expected length of ring to be exactly 2, got {len(data._ring)}.")
-        for i in range(2):
-            writer.add_short(data._ring[i])
-        if data._armlet is None:
-            raise SerializationError("armlet must be provided.")
-        if len(data._armlet) != 2:
-            raise SerializationError(f"Expected length of armlet to be exactly 2, got {len(data._armlet)}.")
-        for i in range(2):
-            writer.add_short(data._armlet[i])
-        if data._bracer is None:
-            raise SerializationError("bracer must be provided.")
-        if len(data._bracer) != 2:
-            raise SerializationError(f"Expected length of bracer to be exactly 2, got {len(data._bracer)}.")
-        for i in range(2):
-            writer.add_short(data._bracer[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._boots is None:
+                raise SerializationError("boots must be provided.")
+            writer.add_short(data._boots)
+            if data._gloves is None:
+                raise SerializationError("gloves must be provided.")
+            writer.add_short(data._gloves)
+            if data._accessory is None:
+                raise SerializationError("accessory must be provided.")
+            writer.add_short(data._accessory)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._belt is None:
+                raise SerializationError("belt must be provided.")
+            writer.add_short(data._belt)
+            if data._necklace is None:
+                raise SerializationError("necklace must be provided.")
+            writer.add_short(data._necklace)
+            if data._hat is None:
+                raise SerializationError("hat must be provided.")
+            writer.add_short(data._hat)
+            if data._shield is None:
+                raise SerializationError("shield must be provided.")
+            writer.add_short(data._shield)
+            if data._weapon is None:
+                raise SerializationError("weapon must be provided.")
+            writer.add_short(data._weapon)
+            if data._ring is None:
+                raise SerializationError("ring must be provided.")
+            if len(data._ring) != 2:
+                raise SerializationError(f"Expected length of ring to be exactly 2, got {len(data._ring)}.")
+            for i in range(2):
+                writer.add_short(data._ring[i])
+            if data._armlet is None:
+                raise SerializationError("armlet must be provided.")
+            if len(data._armlet) != 2:
+                raise SerializationError(f"Expected length of armlet to be exactly 2, got {len(data._armlet)}.")
+            for i in range(2):
+                writer.add_short(data._armlet[i])
+            if data._bracer is None:
+                raise SerializationError("bracer must be provided.")
+            if len(data._bracer) != 2:
+                raise SerializationError(f"Expected length of bracer to be exactly 2, got {len(data._bracer)}.")
+            for i in range(2):
+                writer.add_short(data._bracer[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EquipmentWelcome":

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

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

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

@@ -50,13 +50,19 @@ class GlobalBackfillMessage:
             writer (EoWriter): The writer that the data will be serialized to.
             data (GlobalBackfillMessage): The data to serialize.
         """
-        if data._player_name is None:
-            raise SerializationError("player_name must be provided.")
-        writer.add_string(data._player_name)
-        writer.add_byte(0xFF)
-        if data._message is None:
-            raise SerializationError("message must be provided.")
-        writer.add_string(data._message)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._player_name is None:
+                raise SerializationError("player_name must be provided.")
+            writer.add_string(data._player_name)
+            writer.add_byte(0xFF)
+            if data._message is None:
+                raise SerializationError("message must be provided.")
+            writer.add_string(data._message)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GlobalBackfillMessage":

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

@@ -83,15 +83,19 @@ class GroupHealTargetPlayer:
             writer (EoWriter): The writer that the data will be serialized to.
             data (GroupHealTargetPlayer): 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._hp_percentage is None:
-            raise SerializationError("hp_percentage must be provided.")
-        writer.add_char(data._hp_percentage)
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_short(data._hp)
+        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._hp_percentage is None:
+                raise SerializationError("hp_percentage must be provided.")
+            writer.add_char(data._hp_percentage)
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GroupHealTargetPlayer":

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

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

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildAgreeServerPacket(Packet):
+    """
+    Joined guild info
+    """
     _byte_size: int = 0
     _recruiter_id: int = None # type: ignore [assignment]
     _guild_tag: str = None # type: ignore [assignment]
@@ -105,22 +108,28 @@ class GuildAgreeServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildAgreeServerPacket): The data to serialize.
         """
-        if data._recruiter_id is None:
-            raise SerializationError("recruiter_id must be provided.")
-        writer.add_short(data._recruiter_id)
-        writer.add_byte(0xFF)
-        if data._guild_tag is None:
-            raise SerializationError("guild_tag must be provided.")
-        writer.add_string(data._guild_tag)
-        writer.add_byte(0xFF)
-        if data._guild_name is None:
-            raise SerializationError("guild_name must be provided.")
-        writer.add_string(data._guild_name)
-        writer.add_byte(0xFF)
-        if data._rank_name is None:
-            raise SerializationError("rank_name must be provided.")
-        writer.add_string(data._rank_name)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._recruiter_id is None:
+                raise SerializationError("recruiter_id must be provided.")
+            writer.add_short(data._recruiter_id)
+            writer.add_byte(0xFF)
+            if data._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            writer.add_string(data._guild_tag)
+            writer.add_byte(0xFF)
+            if data._guild_name is None:
+                raise SerializationError("guild_name must be provided.")
+            writer.add_string(data._guild_name)
+            writer.add_byte(0xFF)
+            if data._rank_name is None:
+                raise SerializationError("rank_name must be provided.")
+            writer.add_string(data._rank_name)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildAgreeServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildBuyServerPacket(Packet):
+    """
+    Deposit guild bank reply
+    """
     _byte_size: int = 0
     _gold_amount: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class GuildBuyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildBuyServerPacket): 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) -> "GuildBuyServerPacket":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildCreateServerPacket(Packet):
+    """
+    Guild created
+    """
     _byte_size: int = 0
     _leader_player_id: int = None # type: ignore [assignment]
     _guild_tag: str = None # type: ignore [assignment]
@@ -122,25 +125,31 @@ class GuildCreateServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildCreateServerPacket): The data to serialize.
         """
-        if data._leader_player_id is None:
-            raise SerializationError("leader_player_id must be provided.")
-        writer.add_short(data._leader_player_id)
-        writer.add_byte(0xFF)
-        if data._guild_tag is None:
-            raise SerializationError("guild_tag must be provided.")
-        writer.add_string(data._guild_tag)
-        writer.add_byte(0xFF)
-        if data._guild_name is None:
-            raise SerializationError("guild_name must be provided.")
-        writer.add_string(data._guild_name)
-        writer.add_byte(0xFF)
-        if data._rank_name is None:
-            raise SerializationError("rank_name must be provided.")
-        writer.add_string(data._rank_name)
-        writer.add_byte(0xFF)
-        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:
+            writer.string_sanitization_mode = True
+            if data._leader_player_id is None:
+                raise SerializationError("leader_player_id must be provided.")
+            writer.add_short(data._leader_player_id)
+            writer.add_byte(0xFF)
+            if data._guild_tag is None:
+                raise SerializationError("guild_tag must be provided.")
+            writer.add_string(data._guild_tag)
+            writer.add_byte(0xFF)
+            if data._guild_name is None:
+                raise SerializationError("guild_name must be provided.")
+            writer.add_string(data._guild_name)
+            writer.add_byte(0xFF)
+            if data._rank_name is None:
+                raise SerializationError("rank_name must be provided.")
+            writer.add_string(data._rank_name)
+            writer.add_byte(0xFF)
+            if data._gold_amount is None:
+                raise SerializationError("gold_amount must be provided.")
+            writer.add_int(data._gold_amount)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildCreateServerPacket":

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

@@ -10,6 +10,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildKickServerPacket(Packet):
+    """
+    Left the guild
+    """
     _byte_size: int = 0
 
     @property
@@ -60,9 +63,11 @@ class GuildKickServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildKickServerPacket): 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) -> "GuildKickServerPacket":
@@ -79,8 +84,7 @@ class GuildKickServerPacket(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/guild_member.py

@@ -67,17 +67,23 @@ class GuildMember:
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildMember): The data to serialize.
         """
-        if data._rank is None:
-            raise SerializationError("rank must be provided.")
-        writer.add_char(data._rank)
-        writer.add_byte(0xFF)
-        if data._name is None:
-            raise SerializationError("name must be provided.")
-        writer.add_string(data._name)
-        writer.add_byte(0xFF)
-        if data._rank_name is None:
-            raise SerializationError("rank_name must be provided.")
-        writer.add_string(data._rank_name)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._rank is None:
+                raise SerializationError("rank must be provided.")
+            writer.add_char(data._rank)
+            writer.add_byte(0xFF)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            writer.add_string(data._name)
+            writer.add_byte(0xFF)
+            if data._rank_name is None:
+                raise SerializationError("rank_name must be provided.")
+            writer.add_string(data._rank_name)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildMember":

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

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildOpenServerPacket(Packet):
+    """
+    Talk to guild master NPC reply
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
 
@@ -78,9 +81,13 @@ class GuildOpenServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildOpenServerPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_three(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_three(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildOpenServerPacket":

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

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class GuildRankServerPacket(Packet):
+    """
+    Get guild rank list reply
+    """
     _byte_size: int = 0
     _ranks: list[str] = None # type: ignore [assignment]
 
@@ -79,14 +82,19 @@ class GuildRankServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (GuildRankServerPacket): The data to serialize.
         """
-        if data._ranks is None:
-            raise SerializationError("ranks must be provided.")
-        if len(data._ranks) != 9:
-            raise SerializationError(f"Expected length of ranks to be exactly 9, got {len(data._ranks)}.")
-        for i in range(9):
-            if i > 0:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._ranks is None:
+                raise SerializationError("ranks must be provided.")
+            if len(data._ranks) != 9:
+                raise SerializationError(f"Expected length of ranks to be exactly 9, got {len(data._ranks)}.")
+            for i in range(9):
+                writer.add_string(data._ranks[i])
                 writer.add_byte(0xFF)
-            writer.add_string(data._ranks[i])
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "GuildRankServerPacket":
@@ -107,8 +115,7 @@ class GuildRankServerPacket(Packet):
             data._ranks = []
             for i in range(9):
                 data._ranks.append(reader.get_string())
-                if i + 1 < 9:
-                    reader.next_chunk()
+                reader.next_chunk()
             reader.chunked_reading_mode = False
             data._byte_size = reader.position - reader_start_position
             return data