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

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

@@ -0,0 +1,30 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+"""
+Data structures generated from the [eo-protocol](https://github.com/cirras/eo-protocol/tree/master/xml/pub/server/protocol.xml){target="_blank"} XML specification.
+
+Warning:
+  - This subpackage should not be directly imported. 
+  - Instead, import [eolib.protocol.pub.server][] (or the top-level `eolib`).
+"""
+
+from .talk_record import *
+from .talk_message_record import *
+from .talk_file import *
+from .skill_master_skill_record import *
+from .skill_master_record import *
+from .skill_master_file import *
+from .shop_trade_record import *
+from .shop_record import *
+from .shop_file import *
+from .shop_craft_record import *
+from .shop_craft_ingredient_record import *
+from .inn_record import *
+from .inn_question_record import *
+from .inn_file import *
+from .drop_record import *
+from .drop_npc_record import *
+from .drop_file import *

eolib/protocol/_generated/pub/server/drop_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 .drop_npc_record import DropNpcRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class DropFile:
+    """
+    Endless Drop File
+    """
+    _byte_size: int = 0
+    _npcs: tuple[DropNpcRecord, ...]
+
+    def __init__(self, *, npcs: Iterable[DropNpcRecord]):
+        """
+        Create a new instance of DropFile.
+
+        Args:
+            npcs (Iterable[DropNpcRecord]): 
+        """
+        self._npcs = tuple(npcs)
+
+    @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 npcs(self) -> tuple[DropNpcRecord, ...]:
+        return self._npcs
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "DropFile") -> None:
+        """
+        Serializes an instance of `DropFile` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (DropFile): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("EDF", 3, False)
+            if data._npcs is None:
+                raise SerializationError("npcs must be provided.")
+            for i in range(len(data._npcs)):
+                DropNpcRecord.serialize(writer, data._npcs[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "DropFile":
+        """
+        Deserializes an instance of `DropFile` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            DropFile: 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)
+            npcs = []
+            while reader.remaining > 0:
+                npcs.append(DropNpcRecord.deserialize(reader))
+            result = DropFile(npcs=npcs)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"DropFile(byte_size={repr(self._byte_size)}, npcs={repr(self._npcs)})"

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

@@ -0,0 +1,104 @@
+# 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 .drop_record import DropRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class DropNpcRecord:
+    """
+    Record of potential drops from an NPC
+    """
+    _byte_size: int = 0
+    _npc_id: int
+    _drops_count: int
+    _drops: tuple[DropRecord, ...]
+
+    def __init__(self, *, npc_id: int, drops: Iterable[DropRecord]):
+        """
+        Create a new instance of DropNpcRecord.
+
+        Args:
+            npc_id (int): (Value range is 0-64008.)
+            drops (Iterable[DropRecord]): (Length must be 64008 or less.)
+        """
+        self._npc_id = npc_id
+        self._drops = tuple(drops)
+        self._drops_count = len(self._drops)
+
+    @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 npc_id(self) -> int:
+        return self._npc_id
+
+    @property
+    def drops(self) -> tuple[DropRecord, ...]:
+        return self._drops
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "DropNpcRecord") -> None:
+        """
+        Serializes an instance of `DropNpcRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (DropNpcRecord): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._npc_id is None:
+                raise SerializationError("npc_id must be provided.")
+            writer.add_short(data._npc_id)
+            if data._drops_count is None:
+                raise SerializationError("drops_count must be provided.")
+            writer.add_short(data._drops_count)
+            if data._drops is None:
+                raise SerializationError("drops must be provided.")
+            if len(data._drops) > 64008:
+                raise SerializationError(f"Expected length of drops to be 64008 or less, got {len(data._drops)}.")
+            for i in range(data._drops_count):
+                DropRecord.serialize(writer, data._drops[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "DropNpcRecord":
+        """
+        Deserializes an instance of `DropNpcRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            DropNpcRecord: The data to serialize.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            npc_id = reader.get_short()
+            drops_count = reader.get_short()
+            drops = []
+            for i in range(drops_count):
+                drops.append(DropRecord.deserialize(reader))
+            result = DropNpcRecord(npc_id=npc_id, drops=drops)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"DropNpcRecord(byte_size={repr(self._byte_size)}, npc_id={repr(self._npc_id)}, drops={repr(self._drops)})"

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

@@ -0,0 +1,115 @@
+# 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 DropRecord:
+    """
+    Record of an item an NPC can drop when killed
+    """
+    _byte_size: int = 0
+    _item_id: int
+    _min_amount: int
+    _max_amount: int
+    _rate: int
+
+    def __init__(self, *, item_id: int, min_amount: int, max_amount: int, rate: int):
+        """
+        Create a new instance of DropRecord.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+            min_amount (int): (Value range is 0-16194276.)
+            max_amount (int): (Value range is 0-16194276.)
+            rate (int): Chance (x in 64,000) of the item being dropped (Value range is 0-64008.)
+        """
+        self._item_id = item_id
+        self._min_amount = min_amount
+        self._max_amount = max_amount
+        self._rate = rate
+
+    @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 min_amount(self) -> int:
+        return self._min_amount
+
+    @property
+    def max_amount(self) -> int:
+        return self._max_amount
+
+    @property
+    def rate(self) -> int:
+        """
+        Chance (x in 64,000) of the item being dropped
+        """
+        return self._rate
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "DropRecord") -> None:
+        """
+        Serializes an instance of `DropRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (DropRecord): 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._min_amount is None:
+                raise SerializationError("min_amount must be provided.")
+            writer.add_three(data._min_amount)
+            if data._max_amount is None:
+                raise SerializationError("max_amount must be provided.")
+            writer.add_three(data._max_amount)
+            if data._rate is None:
+                raise SerializationError("rate must be provided.")
+            writer.add_short(data._rate)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "DropRecord":
+        """
+        Deserializes an instance of `DropRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            DropRecord: 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()
+            min_amount = reader.get_three()
+            max_amount = reader.get_three()
+            rate = reader.get_short()
+            result = DropRecord(item_id=item_id, min_amount=min_amount, max_amount=max_amount, rate=rate)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"DropRecord(byte_size={repr(self._byte_size)}, item_id={repr(self._item_id)}, min_amount={repr(self._min_amount)}, max_amount={repr(self._max_amount)}, rate={repr(self._rate)})"

eolib/protocol/_generated/pub/server/inn_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 .inn_record import InnRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class InnFile:
+    """
+    Endless Inn File
+    """
+    _byte_size: int = 0
+    _inns: tuple[InnRecord, ...]
+
+    def __init__(self, *, inns: Iterable[InnRecord]):
+        """
+        Create a new instance of InnFile.
+
+        Args:
+            inns (Iterable[InnRecord]): 
+        """
+        self._inns = tuple(inns)
+
+    @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 inns(self) -> tuple[InnRecord, ...]:
+        return self._inns
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "InnFile") -> None:
+        """
+        Serializes an instance of `InnFile` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (InnFile): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            writer.add_fixed_string("EID", 3, False)
+            if data._inns is None:
+                raise SerializationError("inns must be provided.")
+            for i in range(len(data._inns)):
+                InnRecord.serialize(writer, data._inns[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "InnFile":
+        """
+        Deserializes an instance of `InnFile` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            InnFile: 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)
+            inns = []
+            while reader.remaining > 0:
+                inns.append(InnRecord.deserialize(reader))
+            result = InnFile(inns=inns)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"InnFile(byte_size={repr(self._byte_size)}, inns={repr(self._inns)})"

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

@@ -0,0 +1,106 @@
+# 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 InnQuestionRecord:
+    """
+    Record of a question and answer that the player must answer to register citizenship with an inn
+    """
+    _byte_size: int = 0
+    _question_length: int
+    _question: str
+    _answer_length: int
+    _answer: str
+
+    def __init__(self, *, question: str, answer: str):
+        """
+        Create a new instance of InnQuestionRecord.
+
+        Args:
+            question (str): (Length must be 252 or less.)
+            answer (str): (Length must be 252 or less.)
+        """
+        self._question = question
+        self._question_length = len(self._question)
+        self._answer = answer
+        self._answer_length = len(self._answer)
+
+    @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 question(self) -> str:
+        return self._question
+
+    @property
+    def answer(self) -> str:
+        return self._answer
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "InnQuestionRecord") -> None:
+        """
+        Serializes an instance of `InnQuestionRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (InnQuestionRecord): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._question_length is None:
+                raise SerializationError("question_length must be provided.")
+            writer.add_char(data._question_length)
+            if data._question is None:
+                raise SerializationError("question must be provided.")
+            if len(data._question) > 252:
+                raise SerializationError(f"Expected length of question to be 252 or less, got {len(data._question)}.")
+            writer.add_fixed_string(data._question, data._question_length, False)
+            if data._answer_length is None:
+                raise SerializationError("answer_length must be provided.")
+            writer.add_char(data._answer_length)
+            if data._answer is None:
+                raise SerializationError("answer must be provided.")
+            if len(data._answer) > 252:
+                raise SerializationError(f"Expected length of answer to be 252 or less, got {len(data._answer)}.")
+            writer.add_fixed_string(data._answer, data._answer_length, False)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "InnQuestionRecord":
+        """
+        Deserializes an instance of `InnQuestionRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            InnQuestionRecord: The data to serialize.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            question_length = reader.get_char()
+            question = reader.get_fixed_string(question_length, False)
+            answer_length = reader.get_char()
+            answer = reader.get_fixed_string(answer_length, False)
+            result = InnQuestionRecord(question=question, answer=answer)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"InnQuestionRecord(byte_size={repr(self._byte_size)}, question={repr(self._question)}, answer={repr(self._answer)})"