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

eolib/protocol/_generated/pub/server/inn_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 .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: list[InnRecord] = 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 inns(self) -> list[InnRecord]:
+        return self._inns
+
+    @inns.setter
+    def inns(self, inns: list[InnRecord]) -> None:
+        self._inns = 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.
+        """
+        data: InnFile = InnFile()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            reader.get_fixed_string(3, False)
+            data._inns = []
+            while reader.remaining > 0:
+                data._inns.append(InnRecord.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"InnFile(byte_size={repr(self._byte_size)}, inns={repr(self._inns)})"

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

@@ -0,0 +1,119 @@
+# 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 = None # type: ignore [assignment]
+    _question: str = None # type: ignore [assignment]
+    _answer_length: int = None # type: ignore [assignment]
+    _answer: str = 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 question(self) -> str:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        return self._question
+
+    @question.setter
+    def question(self, question: str) -> None:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        self._question = question
+        self._question_length = len(self._question)
+
+    @property
+    def answer(self) -> str:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        return self._answer
+
+    @answer.setter
+    def answer(self, answer: str) -> None:
+        """
+        Note:
+          - Length must be 252 or less.
+        """
+        self._answer = answer
+        self._answer_length = len(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.
+        """
+        data: InnQuestionRecord = InnQuestionRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._question_length = reader.get_char()
+            data._question = reader.get_fixed_string(data._question_length, False)
+            data._answer_length = reader.get_char()
+            data._answer = reader.get_fixed_string(data._answer_length, False)
+            data._byte_size = reader.position - reader_start_position
+            return data
+        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)})"

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

@@ -0,0 +1,383 @@
+# 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 .inn_question_record import InnQuestionRecord
+from ....serialization_error import SerializationError
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class InnRecord:
+    """
+    Record of Inn data in an Endless Inn 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]
+    _spawn_map: int = None # type: ignore [assignment]
+    _spawn_x: int = None # type: ignore [assignment]
+    _spawn_y: int = None # type: ignore [assignment]
+    _sleep_map: int = None # type: ignore [assignment]
+    _sleep_x: int = None # type: ignore [assignment]
+    _sleep_y: int = None # type: ignore [assignment]
+    _alternate_spawn_enabled: bool = None # type: ignore [assignment]
+    _alternate_spawn_map: int = None # type: ignore [assignment]
+    _alternate_spawn_x: int = None # type: ignore [assignment]
+    _alternate_spawn_y: int = None # type: ignore [assignment]
+    _questions: list[InnQuestionRecord] = 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:
+        """
+        Behavior ID of the NPC that runs the inn. 0 for default inn
+
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._behavior_id
+
+    @behavior_id.setter
+    def behavior_id(self, behavior_id: int) -> None:
+        """
+        Behavior ID of the NPC that runs the inn. 0 for default inn
+
+        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 spawn_map(self) -> int:
+        """
+        ID of the map the player is sent to after respawning
+
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._spawn_map
+
+    @spawn_map.setter
+    def spawn_map(self, spawn_map: int) -> None:
+        """
+        ID of the map the player is sent to after respawning
+
+        Note:
+          - Value range is 0-64008.
+        """
+        self._spawn_map = spawn_map
+
+    @property
+    def spawn_x(self) -> int:
+        """
+        X coordinate of the map the player is sent to after respawning
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._spawn_x
+
+    @spawn_x.setter
+    def spawn_x(self, spawn_x: int) -> None:
+        """
+        X coordinate of the map the player is sent to after respawning
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._spawn_x = spawn_x
+
+    @property
+    def spawn_y(self) -> int:
+        """
+        Y coordinate of the map the player is sent to after respawning
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._spawn_y
+
+    @spawn_y.setter
+    def spawn_y(self, spawn_y: int) -> None:
+        """
+        Y coordinate of the map the player is sent to after respawning
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._spawn_y = spawn_y
+
+    @property
+    def sleep_map(self) -> int:
+        """
+        ID of the map the player is sent to after sleeping at the inn
+
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._sleep_map
+
+    @sleep_map.setter
+    def sleep_map(self, sleep_map: int) -> None:
+        """
+        ID of the map the player is sent to after sleeping at the inn
+
+        Note:
+          - Value range is 0-64008.
+        """
+        self._sleep_map = sleep_map
+
+    @property
+    def sleep_x(self) -> int:
+        """
+        X coordinate of the map the player is sent to after sleeping at the inn
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._sleep_x
+
+    @sleep_x.setter
+    def sleep_x(self, sleep_x: int) -> None:
+        """
+        X coordinate of the map the player is sent to after sleeping at the inn
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._sleep_x = sleep_x
+
+    @property
+    def sleep_y(self) -> int:
+        """
+        Y coordinate of the map the player is sent to after sleeping at the inn
+
+        Note:
+          - Value range is 0-252.
+        """
+        return self._sleep_y
+
+    @sleep_y.setter
+    def sleep_y(self, sleep_y: int) -> None:
+        """
+        Y coordinate of the map the player is sent to after sleeping at the inn
+
+        Note:
+          - Value range is 0-252.
+        """
+        self._sleep_y = sleep_y
+
+    @property
+    def alternate_spawn_enabled(self) -> bool:
+        """
+        Flag for an alternate spawn point. If true, the server will use this alternate spawn
+        map, x, and, y based on some other condition.
+
+        In the official server, this is used to respawn new characters on the noob island
+        until they reach a certain level.
+        """
+        return self._alternate_spawn_enabled
+
+    @alternate_spawn_enabled.setter
+    def alternate_spawn_enabled(self, alternate_spawn_enabled: bool) -> None:
+        """
+        Flag for an alternate spawn point. If true, the server will use this alternate spawn
+        map, x, and, y based on some other condition.
+
+        In the official server, this is used to respawn new characters on the noob island
+        until they reach a certain level.
+        """
+        self._alternate_spawn_enabled = alternate_spawn_enabled
+
+    @property
+    def alternate_spawn_map(self) -> int:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._alternate_spawn_map
+
+    @alternate_spawn_map.setter
+    def alternate_spawn_map(self, alternate_spawn_map: int) -> None:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        self._alternate_spawn_map = alternate_spawn_map
+
+    @property
+    def alternate_spawn_x(self) -> int:
+        """
+        Note:
+          - Value range is 0-252.
+        """
+        return self._alternate_spawn_x
+
+    @alternate_spawn_x.setter
+    def alternate_spawn_x(self, alternate_spawn_x: int) -> None:
+        """
+        Note:
+          - Value range is 0-252.
+        """
+        self._alternate_spawn_x = alternate_spawn_x
+
+    @property
+    def alternate_spawn_y(self) -> int:
+        """
+        Note:
+          - Value range is 0-252.
+        """
+        return self._alternate_spawn_y
+
+    @alternate_spawn_y.setter
+    def alternate_spawn_y(self, alternate_spawn_y: int) -> None:
+        """
+        Note:
+          - Value range is 0-252.
+        """
+        self._alternate_spawn_y = alternate_spawn_y
+
+    @property
+    def questions(self) -> list[InnQuestionRecord]:
+        """
+        Note:
+          - Length must be `3`.
+        """
+        return self._questions
+
+    @questions.setter
+    def questions(self, questions: list[InnQuestionRecord]) -> None:
+        """
+        Note:
+          - Length must be `3`.
+        """
+        self._questions = questions
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "InnRecord") -> None:
+        """
+        Serializes an instance of `InnRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (InnRecord): 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._spawn_map is None:
+                raise SerializationError("spawn_map must be provided.")
+            writer.add_short(data._spawn_map)
+            if data._spawn_x is None:
+                raise SerializationError("spawn_x must be provided.")
+            writer.add_char(data._spawn_x)
+            if data._spawn_y is None:
+                raise SerializationError("spawn_y must be provided.")
+            writer.add_char(data._spawn_y)
+            if data._sleep_map is None:
+                raise SerializationError("sleep_map must be provided.")
+            writer.add_short(data._sleep_map)
+            if data._sleep_x is None:
+                raise SerializationError("sleep_x must be provided.")
+            writer.add_char(data._sleep_x)
+            if data._sleep_y is None:
+                raise SerializationError("sleep_y must be provided.")
+            writer.add_char(data._sleep_y)
+            if data._alternate_spawn_enabled is None:
+                raise SerializationError("alternate_spawn_enabled must be provided.")
+            writer.add_char(1 if data._alternate_spawn_enabled else 0)
+            if data._alternate_spawn_map is None:
+                raise SerializationError("alternate_spawn_map must be provided.")
+            writer.add_short(data._alternate_spawn_map)
+            if data._alternate_spawn_x is None:
+                raise SerializationError("alternate_spawn_x must be provided.")
+            writer.add_char(data._alternate_spawn_x)
+            if data._alternate_spawn_y is None:
+                raise SerializationError("alternate_spawn_y must be provided.")
+            writer.add_char(data._alternate_spawn_y)
+            if data._questions is None:
+                raise SerializationError("questions must be provided.")
+            if len(data._questions) != 3:
+                raise SerializationError(f"Expected length of questions to be exactly 3, got {len(data._questions)}.")
+            for i in range(3):
+                InnQuestionRecord.serialize(writer, data._questions[i])
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "InnRecord":
+        """
+        Deserializes an instance of `InnRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            InnRecord: The data to serialize.
+        """
+        data: InnRecord = InnRecord()
+        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._spawn_map = reader.get_short()
+            data._spawn_x = reader.get_char()
+            data._spawn_y = reader.get_char()
+            data._sleep_map = reader.get_short()
+            data._sleep_x = reader.get_char()
+            data._sleep_y = reader.get_char()
+            data._alternate_spawn_enabled = reader.get_char() != 0
+            data._alternate_spawn_map = reader.get_short()
+            data._alternate_spawn_x = reader.get_char()
+            data._alternate_spawn_y = reader.get_char()
+            data._questions = []
+            for i in range(3):
+                data._questions.append(InnQuestionRecord.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"InnRecord(byte_size={repr(self._byte_size)}, behavior_id={repr(self._behavior_id)}, name={repr(self._name)}, spawn_map={repr(self._spawn_map)}, spawn_x={repr(self._spawn_x)}, spawn_y={repr(self._spawn_y)}, sleep_map={repr(self._sleep_map)}, sleep_x={repr(self._sleep_x)}, sleep_y={repr(self._sleep_y)}, alternate_spawn_enabled={repr(self._alternate_spawn_enabled)}, alternate_spawn_map={repr(self._alternate_spawn_map)}, alternate_spawn_x={repr(self._alternate_spawn_x)}, alternate_spawn_y={repr(self._alternate_spawn_y)}, questions={repr(self._questions)})"

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

@@ -0,0 +1,107 @@
+# 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 ShopCraftIngredientRecord:
+    """
+    Record of an ingredient for crafting an item in a shop
+    """
+    _byte_size: int = 0
+    _item_id: int = None # type: ignore [assignment]
+    _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:
+        """
+        Item ID of the craft ingredient, or 0 if the ingredient is not present
+
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._item_id
+
+    @item_id.setter
+    def item_id(self, item_id: int) -> None:
+        """
+        Item ID of the craft ingredient, or 0 if the ingredient is not present
+
+        Note:
+          - Value range is 0-64008.
+        """
+        self._item_id = item_id
+
+    @property
+    def amount(self) -> int:
+        """
+        Note:
+          - Value range is 0-252.
+        """
+        return self._amount
+
+    @amount.setter
+    def amount(self, amount: int) -> None:
+        """
+        Note:
+          - Value range is 0-252.
+        """
+        self._amount = amount
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "ShopCraftIngredientRecord") -> None:
+        """
+        Serializes an instance of `ShopCraftIngredientRecord` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (ShopCraftIngredientRecord): 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._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) -> "ShopCraftIngredientRecord":
+        """
+        Deserializes an instance of `ShopCraftIngredientRecord` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            ShopCraftIngredientRecord: The data to serialize.
+        """
+        data: ShopCraftIngredientRecord = ShopCraftIngredientRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._item_id = reader.get_short()
+            data._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"ShopCraftIngredientRecord(byte_size={repr(self._byte_size)}, item_id={repr(self._item_id)}, amount={repr(self._amount)})"