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

eolib/protocol/_generated/pub/server/shop_craft_record.py

@@ -0,0 +1,110 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+from __future__ import annotations
+from .shop_craft_ingredient_record import ShopCraftIngredientRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class ShopCraftRecord:
+    """
+    Record of an item that can be crafted in a shop
+    """
+    _byte_size: int = 0
+    _item_id: int = None # type: ignore [assignment]
+    _ingredients: list[ShopCraftIngredientRecord] = None # type: ignore [assignment]
+
+    @property
+    def byte_size(self) -> int:
+        """
+        Returns the size of the data that this was deserialized from.
+
+        Returns:
+            int: The size of the data that this was deserialized from.
+        """
+        return self._byte_size
+
+    @property
+    def item_id(self) -> int:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._item_id
+
+    @item_id.setter
+    def item_id(self, item_id: int) -> None:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        self._item_id = item_id
+
+    @property
+    def ingredients(self) -> list[ShopCraftIngredientRecord]:
+        """
+        Note:
+          - Length must be `4`.
+        """
+        return self._ingredients
+
+    @ingredients.setter
+    def ingredients(self, ingredients: list[ShopCraftIngredientRecord]) -> None:
+        """
+        Note:
+          - Length must be `4`.
+        """
+        self._ingredients = ingredients
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "ShopCraftRecord") -> None:
+        """
+        Serializes an instance of `ShopCraftRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (ShopCraftRecord): The data to serialize.
+        """
+        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):
+                ShopCraftIngredientRecord.serialize(writer, data._ingredients[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "ShopCraftRecord":
+        """
+        Deserializes an instance of `ShopCraftRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            ShopCraftRecord: The data to serialize.
+        """
+        data: ShopCraftRecord = ShopCraftRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._item_id = reader.get_short()
+            data._ingredients = []
+            for i in range(4):
+                data._ingredients.append(ShopCraftIngredientRecord.deserialize(reader))
+            data._byte_size = reader.position - reader_start_position
+            return data
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"ShopCraftRecord(byte_size={repr(self._byte_size)}, item_id={repr(self._item_id)}, ingredients={repr(self._ingredients)})"

eolib/protocol/_generated/pub/server/shop_file.py

@@ -0,0 +1,81 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+from __future__ import annotations
+from .shop_record import ShopRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class ShopFile:
+    """
+    Endless Shop File
+    """
+    _byte_size: int = 0
+    _shops: list[ShopRecord] = None # type: ignore [assignment]
+
+    @property
+    def byte_size(self) -> int:
+        """
+        Returns the size of the data that this was deserialized from.
+
+        Returns:
+            int: The size of the data that this was deserialized from.
+        """
+        return self._byte_size
+
+    @property
+    def shops(self) -> list[ShopRecord]:
+        return self._shops
+
+    @shops.setter
+    def shops(self, shops: list[ShopRecord]) -> None:
+        self._shops = shops
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "ShopFile") -> None:
+        """
+        Serializes an instance of `ShopFile` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (ShopFile): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("ESF", 3, False)
+            if data._shops is None:
+                raise SerializationError("shops must be provided.")
+            for i in range(len(data._shops)):
+                ShopRecord.serialize(writer, data._shops[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "ShopFile":
+        """
+        Deserializes an instance of `ShopFile` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            ShopFile: The data to serialize.
+        """
+        data: ShopFile = ShopFile()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            reader.get_fixed_string(3, False)
+            data._shops = []
+            while reader.remaining > 0:
+                data._shops.append(ShopRecord.deserialize(reader))
+            data._byte_size = reader.position - reader_start_position
+            return data
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"ShopFile(byte_size={repr(self._byte_size)}, shops={repr(self._shops)})"

eolib/protocol/_generated/pub/server/shop_record.py

@@ -0,0 +1,253 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+from __future__ import annotations
+from .shop_trade_record import ShopTradeRecord
+from .shop_craft_record import ShopCraftRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class ShopRecord:
+    """
+    Record of Shop data in an Endless Shop File
+    """
+    _byte_size: int = 0
+    _behavior_id: int = None # type: ignore [assignment]
+    _name_length: int = None # type: ignore [assignment]
+    _name: str = None # type: ignore [assignment]
+    _min_level: int = None # type: ignore [assignment]
+    _max_level: int = None # type: ignore [assignment]
+    _class_requirement: int = None # type: ignore [assignment]
+    _trades_count: int = None # type: ignore [assignment]
+    _crafts_count: int = None # type: ignore [assignment]
+    _trades: list[ShopTradeRecord] = None # type: ignore [assignment]
+    _crafts: list[ShopCraftRecord] = None # type: ignore [assignment]
+
+    @property
+    def byte_size(self) -> int:
+        """
+        Returns the size of the data that this was deserialized from.
+
+        Returns:
+            int: The size of the data that this was deserialized from.
+        """
+        return self._byte_size
+
+    @property
+    def behavior_id(self) -> int:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._behavior_id
+
+    @behavior_id.setter
+    def behavior_id(self, behavior_id: int) -> None:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        self._behavior_id = behavior_id
+
+    @property
+    def name(self) -> str:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        return self._name
+
+    @name.setter
+    def name(self, name: str) -> None:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        self._name = name
+        self._name_length = len(self._name)
+
+    @property
+    def min_level(self) -> int:
+        """
+        Minimum level required to use this shop
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._min_level
+
+    @min_level.setter
+    def min_level(self, min_level: int) -> None:
+        """
+        Minimum level required to use this shop
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._min_level = min_level
+
+    @property
+    def max_level(self) -> int:
+        """
+        Maximum level allowed to use this shop
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._max_level
+
+    @max_level.setter
+    def max_level(self, max_level: int) -> None:
+        """
+        Maximum level allowed to use this shop
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._max_level = max_level
+
+    @property
+    def class_requirement(self) -> int:
+        """
+        Class required to use this shop
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._class_requirement
+
+    @class_requirement.setter
+    def class_requirement(self, class_requirement: int) -> None:
+        """
+        Class required to use this shop
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._class_requirement = class_requirement
+
+    @property
+    def trades(self) -> list[ShopTradeRecord]:
+        """
+        Note:
+          - Length must be 64008 or less.
+        """
+        return self._trades
+
+    @trades.setter
+    def trades(self, trades: list[ShopTradeRecord]) -> None:
+        """
+        Note:
+          - Length must be 64008 or less.
+        """
+        self._trades = trades
+        self._trades_count = len(self._trades)
+
+    @property
+    def crafts(self) -> list[ShopCraftRecord]:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        return self._crafts
+
+    @crafts.setter
+    def crafts(self, crafts: list[ShopCraftRecord]) -> None:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        self._crafts = crafts
+        self._crafts_count = len(self._crafts)
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "ShopRecord") -> None:
+        """
+        Serializes an instance of `ShopRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (ShopRecord): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+            if data._name_length is None:
+                raise SerializationError("name_length must be provided.")
+            writer.add_char(data._name_length)
+            if data._name is None:
+                raise SerializationError("name must be provided.")
+            if len(data._name) > 252:
+                raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
+            writer.add_fixed_string(data._name, data._name_length, False)
+            if data._min_level is None:
+                raise SerializationError("min_level must be provided.")
+            writer.add_char(data._min_level)
+            if data._max_level is None:
+                raise SerializationError("max_level must be provided.")
+            writer.add_char(data._max_level)
+            if data._class_requirement is None:
+                raise SerializationError("class_requirement must be provided.")
+            writer.add_char(data._class_requirement)
+            if data._trades_count is None:
+                raise SerializationError("trades_count must be provided.")
+            writer.add_short(data._trades_count)
+            if data._crafts_count is None:
+                raise SerializationError("crafts_count must be provided.")
+            writer.add_char(data._crafts_count)
+            if data._trades is None:
+                raise SerializationError("trades must be provided.")
+            if len(data._trades) > 64008:
+                raise SerializationError(f"Expected length of trades to be 64008 or less, got {len(data._trades)}.")
+            for i in range(data._trades_count):
+                ShopTradeRecord.serialize(writer, data._trades[i])
+            if data._crafts is None:
+                raise SerializationError("crafts must be provided.")
+            if len(data._crafts) > 252:
+                raise SerializationError(f"Expected length of crafts to be 252 or less, got {len(data._crafts)}.")
+            for i in range(data._crafts_count):
+                ShopCraftRecord.serialize(writer, data._crafts[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "ShopRecord":
+        """
+        Deserializes an instance of `ShopRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            ShopRecord: The data to serialize.
+        """
+        data: ShopRecord = ShopRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._behavior_id = reader.get_short()
+            data._name_length = reader.get_char()
+            data._name = reader.get_fixed_string(data._name_length, False)
+            data._min_level = reader.get_char()
+            data._max_level = reader.get_char()
+            data._class_requirement = reader.get_char()
+            data._trades_count = reader.get_short()
+            data._crafts_count = reader.get_char()
+            data._trades = []
+            for i in range(data._trades_count):
+                data._trades.append(ShopTradeRecord.deserialize(reader))
+            data._crafts = []
+            for i in range(data._crafts_count):
+                data._crafts.append(ShopCraftRecord.deserialize(reader))
+            data._byte_size = reader.position - reader_start_position
+            return data
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"ShopRecord(byte_size={repr(self._byte_size)}, behavior_id={repr(self._behavior_id)}, name={repr(self._name)}, min_level={repr(self._min_level)}, max_level={repr(self._max_level)}, class_requirement={repr(self._class_requirement)}, trades={repr(self._trades)}, crafts={repr(self._crafts)})"

eolib/protocol/_generated/pub/server/shop_trade_record.py

@@ -0,0 +1,157 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class ShopTradeRecord:
+    """
+    Record of an item that can be bought or sold in a shop
+    """
+    _byte_size: int = 0
+    _item_id: int = None # type: ignore [assignment]
+    _buy_price: int = None # type: ignore [assignment]
+    _sell_price: int = None # type: ignore [assignment]
+    _max_amount: int = None # type: ignore [assignment]
+
+    @property
+    def byte_size(self) -> int:
+        """
+        Returns the size of the data that this was deserialized from.
+
+        Returns:
+            int: The size of the data that this was deserialized from.
+        """
+        return self._byte_size
+
+    @property
+    def item_id(self) -> int:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._item_id
+
+    @item_id.setter
+    def item_id(self, item_id: int) -> None:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        self._item_id = item_id
+
+    @property
+    def buy_price(self) -> int:
+        """
+        How much it costs to buy the item from the shop
+
+        Note:
+          - Value range is 0-16194276.
+        """
+        return self._buy_price
+
+    @buy_price.setter
+    def buy_price(self, buy_price: int) -> None:
+        """
+        How much it costs to buy the item from the shop
+
+        Note:
+          - Value range is 0-16194276.
+        """
+        self._buy_price = buy_price
+
+    @property
+    def sell_price(self) -> int:
+        """
+        How much the shop will pay for the item
+
+        Note:
+          - Value range is 0-16194276.
+        """
+        return self._sell_price
+
+    @sell_price.setter
+    def sell_price(self, sell_price: int) -> None:
+        """
+        How much the shop will pay for the item
+
+        Note:
+          - Value range is 0-16194276.
+        """
+        self._sell_price = sell_price
+
+    @property
+    def max_amount(self) -> int:
+        """
+        Max amount of the item that can be bought or sold at one time
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._max_amount
+
+    @max_amount.setter
+    def max_amount(self, max_amount: int) -> None:
+        """
+        Max amount of the item that can be bought or sold at one time
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._max_amount = max_amount
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "ShopTradeRecord") -> None:
+        """
+        Serializes an instance of `ShopTradeRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (ShopTradeRecord): The data to serialize.
+        """
+        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_amount is None:
+                raise SerializationError("max_amount must be provided.")
+            writer.add_char(data._max_amount)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "ShopTradeRecord":
+        """
+        Deserializes an instance of `ShopTradeRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            ShopTradeRecord: The data to serialize.
+        """
+        data: ShopTradeRecord = ShopTradeRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._item_id = reader.get_short()
+            data._buy_price = reader.get_three()
+            data._sell_price = reader.get_three()
+            data._max_amount = reader.get_char()
+            data._byte_size = reader.position - reader_start_position
+            return data
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"ShopTradeRecord(byte_size={repr(self._byte_size)}, item_id={repr(self._item_id)}, buy_price={repr(self._buy_price)}, sell_price={repr(self._sell_price)}, max_amount={repr(self._max_amount)})"

eolib/protocol/_generated/pub/server/skill_master_file.py

@@ -0,0 +1,81 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+from __future__ import annotations
+from .skill_master_record import SkillMasterRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class SkillMasterFile:
+    """
+    Endless Skill Master File
+    """
+    _byte_size: int = 0
+    _skill_masters: list[SkillMasterRecord] = None # type: ignore [assignment]
+
+    @property
+    def byte_size(self) -> int:
+        """
+        Returns the size of the data that this was deserialized from.
+
+        Returns:
+            int: The size of the data that this was deserialized from.
+        """
+        return self._byte_size
+
+    @property
+    def skill_masters(self) -> list[SkillMasterRecord]:
+        return self._skill_masters
+
+    @skill_masters.setter
+    def skill_masters(self, skill_masters: list[SkillMasterRecord]) -> None:
+        self._skill_masters = skill_masters
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "SkillMasterFile") -> None:
+        """
+        Serializes an instance of `SkillMasterFile` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (SkillMasterFile): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("EMF", 3, False)
+            if data._skill_masters is None:
+                raise SerializationError("skill_masters must be provided.")
+            for i in range(len(data._skill_masters)):
+                SkillMasterRecord.serialize(writer, data._skill_masters[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "SkillMasterFile":
+        """
+        Deserializes an instance of `SkillMasterFile` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            SkillMasterFile: The data to serialize.
+        """
+        data: SkillMasterFile = SkillMasterFile()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            reader.get_fixed_string(3, False)
+            data._skill_masters = []
+            while reader.remaining > 0:
+                data._skill_masters.append(SkillMasterRecord.deserialize(reader))
+            data._byte_size = reader.position - reader_start_position
+            return data
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"SkillMasterFile(byte_size={repr(self._byte_size)}, skill_masters={repr(self._skill_masters)})"