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

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

@@ -0,0 +1,188 @@
+# 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 collections.abc import Iterable
+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
+    _name_length: int
+    _name: str
+    _min_level: int
+    _max_level: int
+    _class_requirement: int
+    _trades_count: int
+    _crafts_count: int
+    _trades: tuple[ShopTradeRecord, ...]
+    _crafts: tuple[ShopCraftRecord, ...]
+
+    def __init__(self, *, behavior_id: int, name: str, min_level: int, max_level: int, class_requirement: int, trades: Iterable[ShopTradeRecord], crafts: Iterable[ShopCraftRecord]):
+        """
+        Create a new instance of ShopRecord.
+
+        Args:
+            behavior_id (int): (Value range is 0-64008.)
+            name (str): (Length must be 252 or less.)
+            min_level (int): Minimum level required to use this shop (Value range is 0-252.)
+            max_level (int): Maximum level allowed to use this shop (Value range is 0-252.)
+            class_requirement (int): Class required to use this shop (Value range is 0-252.)
+            trades (Iterable[ShopTradeRecord]): (Length must be 64008 or less.)
+            crafts (Iterable[ShopCraftRecord]): (Length must be 252 or less.)
+        """
+        self._behavior_id = behavior_id
+        self._name = name
+        self._name_length = len(self._name)
+        self._min_level = min_level
+        self._max_level = max_level
+        self._class_requirement = class_requirement
+        self._trades = tuple(trades)
+        self._trades_count = len(self._trades)
+        self._crafts = tuple(crafts)
+        self._crafts_count = len(self._crafts)
+
+    @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:
+        return self._behavior_id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def min_level(self) -> int:
+        """
+        Minimum level required to use this shop
+        """
+        return self._min_level
+
+    @property
+    def max_level(self) -> int:
+        """
+        Maximum level allowed to use this shop
+        """
+        return self._max_level
+
+    @property
+    def class_requirement(self) -> int:
+        """
+        Class required to use this shop
+        """
+        return self._class_requirement
+
+    @property
+    def trades(self) -> tuple[ShopTradeRecord, ...]:
+        return self._trades
+
+    @property
+    def crafts(self) -> tuple[ShopCraftRecord, ...]:
+        return 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.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            behavior_id = reader.get_short()
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            min_level = reader.get_char()
+            max_level = reader.get_char()
+            class_requirement = reader.get_char()
+            trades_count = reader.get_short()
+            crafts_count = reader.get_char()
+            trades = []
+            for i in range(trades_count):
+                trades.append(ShopTradeRecord.deserialize(reader))
+            crafts = []
+            for i in range(crafts_count):
+                crafts.append(ShopCraftRecord.deserialize(reader))
+            result = ShopRecord(behavior_id=behavior_id, name=name, min_level=min_level, max_level=max_level, class_requirement=class_requirement, trades=trades, crafts=crafts)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        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,121 @@
+# 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
+    _buy_price: int
+    _sell_price: int
+    _max_amount: int
+
+    def __init__(self, *, item_id: int, buy_price: int, sell_price: int, max_amount: int):
+        """
+        Create a new instance of ShopTradeRecord.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+            buy_price (int): How much it costs to buy the item from the shop (Value range is 0-16194276.)
+            sell_price (int): How much the shop will pay for the item (Value range is 0-16194276.)
+            max_amount (int): Max amount of the item that can be bought or sold at one time (Value range is 0-252.)
+        """
+        self._item_id = item_id
+        self._buy_price = buy_price
+        self._sell_price = sell_price
+        self._max_amount = max_amount
+
+    @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:
+        return self._item_id
+
+    @property
+    def buy_price(self) -> int:
+        """
+        How much it costs to buy the item from the shop
+        """
+        return self._buy_price
+
+    @property
+    def sell_price(self) -> int:
+        """
+        How much the shop will pay for the item
+        """
+        return self._sell_price
+
+    @property
+    def max_amount(self) -> int:
+        """
+        Max amount of the item that can be bought or sold at one time
+        """
+        return self._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.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            item_id = reader.get_short()
+            buy_price = reader.get_three()
+            sell_price = reader.get_three()
+            max_amount = reader.get_char()
+            result = ShopTradeRecord(item_id=item_id, buy_price=buy_price, sell_price=sell_price, max_amount=max_amount)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        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,87 @@
+# 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 collections.abc import Iterable
+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: tuple[SkillMasterRecord, ...]
+
+    def __init__(self, *, skill_masters: Iterable[SkillMasterRecord]):
+        """
+        Create a new instance of SkillMasterFile.
+
+        Args:
+            skill_masters (Iterable[SkillMasterRecord]): 
+        """
+        self._skill_masters = tuple(skill_masters)
+
+    @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) -> tuple[SkillMasterRecord, ...]:
+        return self._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.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            reader.get_fixed_string(3, False)
+            skill_masters = []
+            while reader.remaining > 0:
+                skill_masters.append(SkillMasterRecord.deserialize(reader))
+            result = SkillMasterFile(skill_masters=skill_masters)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        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)})"

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

@@ -0,0 +1,168 @@
+# 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 collections.abc import Iterable
+from .skill_master_skill_record import SkillMasterSkillRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class SkillMasterRecord:
+    """
+    Record of Skill Master data in an Endless Skill Master File
+    """
+    _byte_size: int = 0
+    _behavior_id: int
+    _name_length: int
+    _name: str
+    _min_level: int
+    _max_level: int
+    _class_requirement: int
+    _skills_count: int
+    _skills: tuple[SkillMasterSkillRecord, ...]
+
+    def __init__(self, *, behavior_id: int, name: str, min_level: int, max_level: int, class_requirement: int, skills: Iterable[SkillMasterSkillRecord]):
+        """
+        Create a new instance of SkillMasterRecord.
+
+        Args:
+            behavior_id (int): Behavior ID of the Skill Master NPC (Value range is 0-64008.)
+            name (str): (Length must be 252 or less.)
+            min_level (int): Minimum level required to use this Skill Master (Value range is 0-252.)
+            max_level (int): Maximum level allowed to use this Skill Master (Value range is 0-252.)
+            class_requirement (int): Class required to use this Skill Master (Value range is 0-252.)
+            skills (Iterable[SkillMasterSkillRecord]): (Length must be 64008 or less.)
+        """
+        self._behavior_id = behavior_id
+        self._name = name
+        self._name_length = len(self._name)
+        self._min_level = min_level
+        self._max_level = max_level
+        self._class_requirement = class_requirement
+        self._skills = tuple(skills)
+        self._skills_count = len(self._skills)
+
+    @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:
+        """
+        Behavior ID of the Skill Master NPC
+        """
+        return self._behavior_id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def min_level(self) -> int:
+        """
+        Minimum level required to use this Skill Master
+        """
+        return self._min_level
+
+    @property
+    def max_level(self) -> int:
+        """
+        Maximum level allowed to use this Skill Master
+        """
+        return self._max_level
+
+    @property
+    def class_requirement(self) -> int:
+        """
+        Class required to use this Skill Master
+        """
+        return self._class_requirement
+
+    @property
+    def skills(self) -> tuple[SkillMasterSkillRecord, ...]:
+        return self._skills
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "SkillMasterRecord") -> None:
+        """
+        Serializes an instance of `SkillMasterRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (SkillMasterRecord): 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._skills_count is None:
+                raise SerializationError("skills_count must be provided.")
+            writer.add_short(data._skills_count)
+            if data._skills is None:
+                raise SerializationError("skills must be provided.")
+            if len(data._skills) > 64008:
+                raise SerializationError(f"Expected length of skills to be 64008 or less, got {len(data._skills)}.")
+            for i in range(data._skills_count):
+                SkillMasterSkillRecord.serialize(writer, data._skills[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "SkillMasterRecord":
+        """
+        Deserializes an instance of `SkillMasterRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            SkillMasterRecord: The data to serialize.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            behavior_id = reader.get_short()
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            min_level = reader.get_char()
+            max_level = reader.get_char()
+            class_requirement = reader.get_char()
+            skills_count = reader.get_short()
+            skills = []
+            for i in range(skills_count):
+                skills.append(SkillMasterSkillRecord.deserialize(reader))
+            result = SkillMasterRecord(behavior_id=behavior_id, name=name, min_level=min_level, max_level=max_level, class_requirement=class_requirement, skills=skills)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"SkillMasterRecord(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)}, skills={repr(self._skills)})"