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

eolib/protocol/_generated/map/map_tile_spec_row_tile.py

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

eolib/protocol/_generated/map/map_warp.py

@@ -93,18 +93,22 @@ class MapWarp:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapWarp): The data to serialize.
         """
-        if data._destination_map is None:
-            raise SerializationError("destination_map must be provided.")
-        writer.add_short(data._destination_map)
-        if data._destination_coords is None:
-            raise SerializationError("destination_coords must be provided.")
-        Coords.serialize(writer, data._destination_coords)
-        if data._level_required is None:
-            raise SerializationError("level_required must be provided.")
-        writer.add_char(data._level_required)
-        if data._door is None:
-            raise SerializationError("door must be provided.")
-        writer.add_short(data._door)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._destination_map is None:
+                raise SerializationError("destination_map must be provided.")
+            writer.add_short(data._destination_map)
+            if data._destination_coords is None:
+                raise SerializationError("destination_coords must be provided.")
+            Coords.serialize(writer, data._destination_coords)
+            if data._level_required is None:
+                raise SerializationError("level_required must be provided.")
+            writer.add_char(data._level_required)
+            if data._door is None:
+                raise SerializationError("door must be provided.")
+            writer.add_short(data._door)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapWarp":

eolib/protocol/_generated/map/map_warp_row.py

@@ -70,18 +70,22 @@ class MapWarpRow:
             writer (EoWriter): The writer that the data will be serialized to.
             data (MapWarpRow): The data to serialize.
         """
-        if data._y is None:
-            raise SerializationError("y must be provided.")
-        writer.add_char(data._y)
-        if data._tiles_count is None:
-            raise SerializationError("tiles_count must be provided.")
-        writer.add_char(data._tiles_count)
-        if data._tiles is None:
-            raise SerializationError("tiles must be provided.")
-        if len(data._tiles) > 252:
-            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
-        for i in range(data._tiles_count):
-            MapWarpRowTile.serialize(writer, data._tiles[i])
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._y is None:
+                raise SerializationError("y must be provided.")
+            writer.add_char(data._y)
+            if data._tiles_count is None:
+                raise SerializationError("tiles_count must be provided.")
+            writer.add_char(data._tiles_count)
+            if data._tiles is None:
+                raise SerializationError("tiles must be provided.")
+            if len(data._tiles) > 252:
+                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
+            for i in range(data._tiles_count):
+                MapWarpRowTile.serialize(writer, data._tiles[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "MapWarpRow":

eolib/protocol/_generated/map/map_warp_row_tile.py

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

eolib/protocol/_generated/net/char_item.py

@@ -67,12 +67,16 @@ class CharItem:
             writer (EoWriter): The writer that the data will be serialized to.
             data (CharItem): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_char(data._amount)
+        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._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_char(data._amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "CharItem":

eolib/protocol/_generated/net/client/account_agree_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AccountAgreeClientPacket(Packet):
+    """
+    Change password
+    """
     _byte_size: int = 0
     _username: str = None # type: ignore [assignment]
     _old_password: str = None # type: ignore [assignment]
@@ -88,18 +91,24 @@ class AccountAgreeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AccountAgreeClientPacket): The data to serialize.
         """
-        if data._username is None:
-            raise SerializationError("username must be provided.")
-        writer.add_string(data._username)
-        writer.add_byte(0xFF)
-        if data._old_password is None:
-            raise SerializationError("old_password must be provided.")
-        writer.add_string(data._old_password)
-        writer.add_byte(0xFF)
-        if data._new_password is None:
-            raise SerializationError("new_password must be provided.")
-        writer.add_string(data._new_password)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._username is None:
+                raise SerializationError("username must be provided.")
+            writer.add_string(data._username)
+            writer.add_byte(0xFF)
+            if data._old_password is None:
+                raise SerializationError("old_password must be provided.")
+            writer.add_string(data._old_password)
+            writer.add_byte(0xFF)
+            if data._new_password is None:
+                raise SerializationError("new_password must be provided.")
+            writer.add_string(data._new_password)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AccountAgreeClientPacket":

eolib/protocol/_generated/net/client/account_create_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AccountCreateClientPacket(Packet):
+    """
+    Confirm creating an account
+    """
     _byte_size: int = 0
     _session_id: int = None # type: ignore [assignment]
     _username: str = None # type: ignore [assignment]
@@ -141,38 +144,44 @@ class AccountCreateClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AccountCreateClientPacket): The data to serialize.
         """
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_short(data._session_id)
-        writer.add_byte(0xFF)
-        if data._username is None:
-            raise SerializationError("username must be provided.")
-        writer.add_string(data._username)
-        writer.add_byte(0xFF)
-        if data._password is None:
-            raise SerializationError("password must be provided.")
-        writer.add_string(data._password)
-        writer.add_byte(0xFF)
-        if data._full_name is None:
-            raise SerializationError("full_name must be provided.")
-        writer.add_string(data._full_name)
-        writer.add_byte(0xFF)
-        if data._location is None:
-            raise SerializationError("location must be provided.")
-        writer.add_string(data._location)
-        writer.add_byte(0xFF)
-        if data._email is None:
-            raise SerializationError("email must be provided.")
-        writer.add_string(data._email)
-        writer.add_byte(0xFF)
-        if data._computer is None:
-            raise SerializationError("computer must be provided.")
-        writer.add_string(data._computer)
-        writer.add_byte(0xFF)
-        if data._hdid is None:
-            raise SerializationError("hdid must be provided.")
-        writer.add_string(data._hdid)
-        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)
+            writer.add_byte(0xFF)
+            if data._username is None:
+                raise SerializationError("username must be provided.")
+            writer.add_string(data._username)
+            writer.add_byte(0xFF)
+            if data._password is None:
+                raise SerializationError("password must be provided.")
+            writer.add_string(data._password)
+            writer.add_byte(0xFF)
+            if data._full_name is None:
+                raise SerializationError("full_name must be provided.")
+            writer.add_string(data._full_name)
+            writer.add_byte(0xFF)
+            if data._location is None:
+                raise SerializationError("location must be provided.")
+            writer.add_string(data._location)
+            writer.add_byte(0xFF)
+            if data._email is None:
+                raise SerializationError("email must be provided.")
+            writer.add_string(data._email)
+            writer.add_byte(0xFF)
+            if data._computer is None:
+                raise SerializationError("computer must be provided.")
+            writer.add_string(data._computer)
+            writer.add_byte(0xFF)
+            if data._hdid is None:
+                raise SerializationError("hdid must be provided.")
+            writer.add_string(data._hdid)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AccountCreateClientPacket":

eolib/protocol/_generated/net/client/account_request_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AccountRequestClientPacket(Packet):
+    """
+    Request creating an account
+    """
     _byte_size: int = 0
     _username: str = None # type: ignore [assignment]
 
@@ -70,9 +73,13 @@ class AccountRequestClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AccountRequestClientPacket): The data to serialize.
         """
-        if data._username is None:
-            raise SerializationError("username must be provided.")
-        writer.add_string(data._username)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._username is None:
+                raise SerializationError("username must be provided.")
+            writer.add_string(data._username)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AccountRequestClientPacket":

eolib/protocol/_generated/net/client/admin_interact_report_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AdminInteractReportClientPacket(Packet):
+    """
+    Report character
+    """
     _byte_size: int = 0
     _reportee: str = None # type: ignore [assignment]
     _message: str = None # type: ignore [assignment]
@@ -79,13 +82,19 @@ class AdminInteractReportClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AdminInteractReportClientPacket): The data to serialize.
         """
-        if data._reportee is None:
-            raise SerializationError("reportee must be provided.")
-        writer.add_string(data._reportee)
-        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._reportee is None:
+                raise SerializationError("reportee must be provided.")
+            writer.add_string(data._reportee)
+            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) -> "AdminInteractReportClientPacket":

eolib/protocol/_generated/net/client/admin_interact_tell_client_packet.py

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

eolib/protocol/_generated/net/client/attack_use_client_packet.py

@@ -12,6 +12,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class AttackUseClientPacket(Packet):
+    """
+    Attacking
+    """
     _byte_size: int = 0
     _direction: Direction = None # type: ignore [assignment]
     _timestamp: int = None # type: ignore [assignment]
@@ -88,12 +91,16 @@ class AttackUseClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (AttackUseClientPacket): The data to serialize.
         """
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
-        if data._timestamp is None:
-            raise SerializationError("timestamp must be provided.")
-        writer.add_three(data._timestamp)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+            if data._timestamp is None:
+                raise SerializationError("timestamp must be provided.")
+            writer.add_three(data._timestamp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "AttackUseClientPacket":

eolib/protocol/_generated/net/client/bank_add_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BankAddClientPacket(Packet):
+    """
+    Depositing gold
+    """
     _byte_size: int = 0
     _amount: int = None # type: ignore [assignment]
     _session_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class BankAddClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BankAddClientPacket): The data to serialize.
         """
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_int(data._amount)
-        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._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_int(data._amount)
+            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) -> "BankAddClientPacket":

eolib/protocol/_generated/net/client/bank_open_client_packet.py

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

eolib/protocol/_generated/net/client/bank_take_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BankTakeClientPacket(Packet):
+    """
+    Withdrawing gold
+    """
     _byte_size: int = 0
     _amount: int = None # type: ignore [assignment]
     _session_id: int = None # type: ignore [assignment]
@@ -95,12 +98,16 @@ class BankTakeClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BankTakeClientPacket): The data to serialize.
         """
-        if data._amount is None:
-            raise SerializationError("amount must be provided.")
-        writer.add_int(data._amount)
-        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._amount is None:
+                raise SerializationError("amount must be provided.")
+            writer.add_int(data._amount)
+            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) -> "BankTakeClientPacket":

eolib/protocol/_generated/net/client/barber_buy_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BarberBuyClientPacket(Packet):
+    """
+    Purchasing a hair-style
+    """
     _byte_size: int = 0
     _hair_style: int = None # type: ignore [assignment]
     _hair_color: int = None # type: ignore [assignment]
@@ -112,15 +115,19 @@ class BarberBuyClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BarberBuyClientPacket): The data to serialize.
         """
-        if data._hair_style is None:
-            raise SerializationError("hair_style must be provided.")
-        writer.add_char(data._hair_style)
-        if data._hair_color is None:
-            raise SerializationError("hair_color must be provided.")
-        writer.add_char(data._hair_color)
-        if data._session_id is None:
-            raise SerializationError("session_id must be provided.")
-        writer.add_int(data._session_id)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._hair_style is None:
+                raise SerializationError("hair_style must be provided.")
+            writer.add_char(data._hair_style)
+            if data._hair_color is None:
+                raise SerializationError("hair_color must be provided.")
+            writer.add_char(data._hair_color)
+            if data._session_id is None:
+                raise SerializationError("session_id must be provided.")
+            writer.add_int(data._session_id)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BarberBuyClientPacket":

eolib/protocol/_generated/net/client/barber_open_client_packet.py

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

eolib/protocol/_generated/net/client/board_create_client_packet.py

@@ -11,6 +11,9 @@ from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
 
 class BoardCreateClientPacket(Packet):
+    """
+    Posting a new message to a town board
+    """
     _byte_size: int = 0
     _board_id: int = None # type: ignore [assignment]
     _post_subject: str = None # type: ignore [assignment]
@@ -96,18 +99,24 @@ class BoardCreateClientPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (BoardCreateClientPacket): The data to serialize.
         """
-        if data._board_id is None:
-            raise SerializationError("board_id must be provided.")
-        writer.add_short(data._board_id)
-        writer.add_byte(0xFF)
-        if data._post_subject is None:
-            raise SerializationError("post_subject must be provided.")
-        writer.add_string(data._post_subject)
-        writer.add_byte(0xFF)
-        if data._post_body is None:
-            raise SerializationError("post_body must be provided.")
-        writer.add_string(data._post_body)
-        writer.add_byte(0xFF)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.string_sanitization_mode = True
+            if data._board_id is None:
+                raise SerializationError("board_id must be provided.")
+            writer.add_short(data._board_id)
+            writer.add_byte(0xFF)
+            if data._post_subject is None:
+                raise SerializationError("post_subject must be provided.")
+            writer.add_string(data._post_subject)
+            writer.add_byte(0xFF)
+            if data._post_body is None:
+                raise SerializationError("post_body must be provided.")
+            writer.add_string(data._post_body)
+            writer.add_byte(0xFF)
+            writer.string_sanitization_mode = False
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "BoardCreateClientPacket":