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

eolib/protocol/_generated/pub/esf_record.py

@@ -511,108 +511,112 @@ class EsfRecord:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EsfRecord): The data to serialize.
         """
-        if data._name_length is None:
-            raise SerializationError("name_length must be provided.")
-        writer.add_char(data._name_length)
-        if data._chant_length is None:
-            raise SerializationError("chant_length must be provided.")
-        writer.add_char(data._chant_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._chant is None:
-            raise SerializationError("chant must be provided.")
-        if len(data._chant) > 252:
-            raise SerializationError(f"Expected length of chant to be 252 or less, got {len(data._chant)}.")
-        writer.add_fixed_string(data._chant, data._chant_length, False)
-        if data._icon_id is None:
-            raise SerializationError("icon_id must be provided.")
-        writer.add_short(data._icon_id)
-        if data._graphic_id is None:
-            raise SerializationError("graphic_id must be provided.")
-        writer.add_short(data._graphic_id)
-        if data._tp_cost is None:
-            raise SerializationError("tp_cost must be provided.")
-        writer.add_short(data._tp_cost)
-        if data._sp_cost is None:
-            raise SerializationError("sp_cost must be provided.")
-        writer.add_short(data._sp_cost)
-        if data._cast_time is None:
-            raise SerializationError("cast_time must be provided.")
-        writer.add_char(data._cast_time)
-        if data._nature is None:
-            raise SerializationError("nature must be provided.")
-        writer.add_char(int(data._nature))
-        writer.add_char(1)
-        if data._type is None:
-            raise SerializationError("type must be provided.")
-        writer.add_three(int(data._type))
-        if data._element is None:
-            raise SerializationError("element must be provided.")
-        writer.add_char(int(data._element))
-        if data._element_power is None:
-            raise SerializationError("element_power must be provided.")
-        writer.add_short(data._element_power)
-        if data._target_restrict is None:
-            raise SerializationError("target_restrict must be provided.")
-        writer.add_char(int(data._target_restrict))
-        if data._target_type is None:
-            raise SerializationError("target_type must be provided.")
-        writer.add_char(int(data._target_type))
-        if data._target_time is None:
-            raise SerializationError("target_time must be provided.")
-        writer.add_char(data._target_time)
-        writer.add_char(0)
-        if data._max_skill_level is None:
-            raise SerializationError("max_skill_level must be provided.")
-        writer.add_short(data._max_skill_level)
-        if data._min_damage is None:
-            raise SerializationError("min_damage must be provided.")
-        writer.add_short(data._min_damage)
-        if data._max_damage is None:
-            raise SerializationError("max_damage must be provided.")
-        writer.add_short(data._max_damage)
-        if data._accuracy is None:
-            raise SerializationError("accuracy must be provided.")
-        writer.add_short(data._accuracy)
-        if data._evade is None:
-            raise SerializationError("evade must be provided.")
-        writer.add_short(data._evade)
-        if data._armor is None:
-            raise SerializationError("armor must be provided.")
-        writer.add_short(data._armor)
-        if data._return_damage is None:
-            raise SerializationError("return_damage must be provided.")
-        writer.add_char(data._return_damage)
-        if data._hp_heal is None:
-            raise SerializationError("hp_heal must be provided.")
-        writer.add_short(data._hp_heal)
-        if data._tp_heal is None:
-            raise SerializationError("tp_heal must be provided.")
-        writer.add_short(data._tp_heal)
-        if data._sp_heal is None:
-            raise SerializationError("sp_heal must be provided.")
-        writer.add_char(data._sp_heal)
-        if data._str is None:
-            raise SerializationError("str must be provided.")
-        writer.add_short(data._str)
-        if data._intl is None:
-            raise SerializationError("intl must be provided.")
-        writer.add_short(data._intl)
-        if data._wis is None:
-            raise SerializationError("wis must be provided.")
-        writer.add_short(data._wis)
-        if data._agi is None:
-            raise SerializationError("agi must be provided.")
-        writer.add_short(data._agi)
-        if data._con is None:
-            raise SerializationError("con must be provided.")
-        writer.add_short(data._con)
-        if data._cha is None:
-            raise SerializationError("cha must be provided.")
-        writer.add_short(data._cha)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._name_length is None:
+                raise SerializationError("name_length must be provided.")
+            writer.add_char(data._name_length)
+            if data._chant_length is None:
+                raise SerializationError("chant_length must be provided.")
+            writer.add_char(data._chant_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._chant is None:
+                raise SerializationError("chant must be provided.")
+            if len(data._chant) > 252:
+                raise SerializationError(f"Expected length of chant to be 252 or less, got {len(data._chant)}.")
+            writer.add_fixed_string(data._chant, data._chant_length, False)
+            if data._icon_id is None:
+                raise SerializationError("icon_id must be provided.")
+            writer.add_short(data._icon_id)
+            if data._graphic_id is None:
+                raise SerializationError("graphic_id must be provided.")
+            writer.add_short(data._graphic_id)
+            if data._tp_cost is None:
+                raise SerializationError("tp_cost must be provided.")
+            writer.add_short(data._tp_cost)
+            if data._sp_cost is None:
+                raise SerializationError("sp_cost must be provided.")
+            writer.add_short(data._sp_cost)
+            if data._cast_time is None:
+                raise SerializationError("cast_time must be provided.")
+            writer.add_char(data._cast_time)
+            if data._nature is None:
+                raise SerializationError("nature must be provided.")
+            writer.add_char(int(data._nature))
+            writer.add_char(1)
+            if data._type is None:
+                raise SerializationError("type must be provided.")
+            writer.add_three(int(data._type))
+            if data._element is None:
+                raise SerializationError("element must be provided.")
+            writer.add_char(int(data._element))
+            if data._element_power is None:
+                raise SerializationError("element_power must be provided.")
+            writer.add_short(data._element_power)
+            if data._target_restrict is None:
+                raise SerializationError("target_restrict must be provided.")
+            writer.add_char(int(data._target_restrict))
+            if data._target_type is None:
+                raise SerializationError("target_type must be provided.")
+            writer.add_char(int(data._target_type))
+            if data._target_time is None:
+                raise SerializationError("target_time must be provided.")
+            writer.add_char(data._target_time)
+            writer.add_char(0)
+            if data._max_skill_level is None:
+                raise SerializationError("max_skill_level must be provided.")
+            writer.add_short(data._max_skill_level)
+            if data._min_damage is None:
+                raise SerializationError("min_damage must be provided.")
+            writer.add_short(data._min_damage)
+            if data._max_damage is None:
+                raise SerializationError("max_damage must be provided.")
+            writer.add_short(data._max_damage)
+            if data._accuracy is None:
+                raise SerializationError("accuracy must be provided.")
+            writer.add_short(data._accuracy)
+            if data._evade is None:
+                raise SerializationError("evade must be provided.")
+            writer.add_short(data._evade)
+            if data._armor is None:
+                raise SerializationError("armor must be provided.")
+            writer.add_short(data._armor)
+            if data._return_damage is None:
+                raise SerializationError("return_damage must be provided.")
+            writer.add_char(data._return_damage)
+            if data._hp_heal is None:
+                raise SerializationError("hp_heal must be provided.")
+            writer.add_short(data._hp_heal)
+            if data._tp_heal is None:
+                raise SerializationError("tp_heal must be provided.")
+            writer.add_short(data._tp_heal)
+            if data._sp_heal is None:
+                raise SerializationError("sp_heal must be provided.")
+            writer.add_char(data._sp_heal)
+            if data._str is None:
+                raise SerializationError("str must be provided.")
+            writer.add_short(data._str)
+            if data._intl is None:
+                raise SerializationError("intl must be provided.")
+            writer.add_short(data._intl)
+            if data._wis is None:
+                raise SerializationError("wis must be provided.")
+            writer.add_short(data._wis)
+            if data._agi is None:
+                raise SerializationError("agi must be provided.")
+            writer.add_short(data._agi)
+            if data._con is None:
+                raise SerializationError("con must be provided.")
+            writer.add_short(data._con)
+            if data._cha is None:
+                raise SerializationError("cha must be provided.")
+            writer.add_short(data._cha)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EsfRecord":

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,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 .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: list[DropNpcRecord] = 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 npcs(self) -> list[DropNpcRecord]:
+        return self._npcs
+
+    @npcs.setter
+    def npcs(self, npcs: list[DropNpcRecord]) -> None:
+        self._npcs = 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.
+        """
+        data: DropFile = DropFile()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            reader.get_fixed_string(3, False)
+            data._npcs = []
+            while reader.remaining > 0:
+                data._npcs.append(DropNpcRecord.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"DropFile(byte_size={repr(self._byte_size)}, npcs={repr(self._npcs)})"

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

@@ -0,0 +1,116 @@
+# 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 .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 = None # type: ignore [assignment]
+    _drops_count: int = None # type: ignore [assignment]
+    _drops: list[DropRecord] = 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 npc_id(self) -> int:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._npc_id
+
+    @npc_id.setter
+    def npc_id(self, npc_id: int) -> None:
+        """
+        Note:
+          - Value range is 0-64008.
+        """
+        self._npc_id = npc_id
+
+    @property
+    def drops(self) -> list[DropRecord]:
+        """
+        Note:
+          - Length must be 64008 or less.
+        """
+        return self._drops
+
+    @drops.setter
+    def drops(self, drops: list[DropRecord]) -> None:
+        """
+        Note:
+          - Length must be 64008 or less.
+        """
+        self._drops = drops
+        self._drops_count = len(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.
+        """
+        data: DropNpcRecord = DropNpcRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._npc_id = reader.get_short()
+            data._drops_count = reader.get_short()
+            data._drops = []
+            for i in range(data._drops_count):
+                data._drops.append(DropRecord.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"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,149 @@
+# 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 = None # type: ignore [assignment]
+    _min_amount: int = None # type: ignore [assignment]
+    _max_amount: int = None # type: ignore [assignment]
+    _rate: 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 min_amount(self) -> int:
+        """
+        Note:
+          - Value range is 0-16194276.
+        """
+        return self._min_amount
+
+    @min_amount.setter
+    def min_amount(self, min_amount: int) -> None:
+        """
+        Note:
+          - Value range is 0-16194276.
+        """
+        self._min_amount = min_amount
+
+    @property
+    def max_amount(self) -> int:
+        """
+        Note:
+          - Value range is 0-16194276.
+        """
+        return self._max_amount
+
+    @max_amount.setter
+    def max_amount(self, max_amount: int) -> None:
+        """
+        Note:
+          - Value range is 0-16194276.
+        """
+        self._max_amount = max_amount
+
+    @property
+    def rate(self) -> int:
+        """
+        Chance (x in 64,000) of the item being dropped
+
+        Note:
+          - Value range is 0-64008.
+        """
+        return self._rate
+
+    @rate.setter
+    def rate(self, rate: int) -> None:
+        """
+        Chance (x in 64,000) of the item being dropped
+
+        Note:
+          - Value range is 0-64008.
+        """
+        self._rate = 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.
+        """
+        data: DropRecord = DropRecord()
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            data._item_id = reader.get_short()
+            data._min_amount = reader.get_three()
+            data._max_amount = reader.get_three()
+            data._rate = reader.get_short()
+            data._byte_size = reader.position - reader_start_position
+            return data
+        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)})"