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

eolib/protocol/_generated/net/server/skill_learn.py

@@ -4,7 +4,8 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
-from .character_base_stats import CharacterBaseStats
+from collections.abc import Iterable
+from .skill_stat_requirements import SkillStatRequirements
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
 from .....data.eo_reader import EoReader
@@ -14,12 +15,31 @@ class SkillLearn:
     A skill that can be learned from a skill master NPC
     """
     _byte_size: int = 0
-    _id: int = None # type: ignore [assignment]
-    _level_requirement: int = None # type: ignore [assignment]
-    _class_requirement: int = None # type: ignore [assignment]
-    _cost: int = None # type: ignore [assignment]
-    _skill_requirements: list[int] = None # type: ignore [assignment]
-    _stat_requirements: CharacterBaseStats = None # type: ignore [assignment]
+    _id: int
+    _level_requirement: int
+    _class_requirement: int
+    _cost: int
+    _skill_requirements: tuple[int, ...]
+    _stat_requirements: SkillStatRequirements
+
+    def __init__(self, *, id: int, level_requirement: int, class_requirement: int, cost: int, skill_requirements: Iterable[int], stat_requirements: SkillStatRequirements):
+        """
+        Create a new instance of SkillLearn.
+
+        Args:
+            id (int): (Value range is 0-64008.)
+            level_requirement (int): (Value range is 0-252.)
+            class_requirement (int): (Value range is 0-252.)
+            cost (int): (Value range is 0-4097152080.)
+            skill_requirements (Iterable[int]): (Length must be `4`.) (Element value range is 0-64008.)
+            stat_requirements (SkillStatRequirements): 
+        """
+        self._id = id
+        self._level_requirement = level_requirement
+        self._class_requirement = class_requirement
+        self._cost = cost
+        self._skill_requirements = tuple(skill_requirements)
+        self._stat_requirements = stat_requirements
 
     @property
     def byte_size(self) -> int:
@@ -33,94 +53,28 @@ class SkillLearn:
 
     @property
     def id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._id
 
-    @id.setter
-    def id(self, id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._id = id
-
     @property
     def level_requirement(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._level_requirement
 
-    @level_requirement.setter
-    def level_requirement(self, level_requirement: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._level_requirement = level_requirement
-
     @property
     def class_requirement(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._class_requirement
 
-    @class_requirement.setter
-    def class_requirement(self, class_requirement: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._class_requirement = class_requirement
-
     @property
     def cost(self) -> int:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
         return self._cost
 
-    @cost.setter
-    def cost(self, cost: int) -> None:
-        """
-        Note:
-          - Value range is 0-4097152080.
-        """
-        self._cost = cost
-
     @property
-    def skill_requirements(self) -> list[int]:
-        """
-        Note:
-          - Length must be `4`.
-          - Element value range is 0-64008.
-        """
+    def skill_requirements(self) -> tuple[int, ...]:
         return self._skill_requirements
 
-    @skill_requirements.setter
-    def skill_requirements(self, skill_requirements: list[int]) -> None:
-        """
-        Note:
-          - Length must be `4`.
-          - Element value range is 0-64008.
-        """
-        self._skill_requirements = skill_requirements
-
     @property
-    def stat_requirements(self) -> CharacterBaseStats:
+    def stat_requirements(self) -> SkillStatRequirements:
         return self._stat_requirements
 
-    @stat_requirements.setter
-    def stat_requirements(self, stat_requirements: CharacterBaseStats) -> None:
-        self._stat_requirements = stat_requirements
-
     @staticmethod
     def serialize(writer: EoWriter, data: "SkillLearn") -> None:
         """
@@ -130,27 +84,31 @@ class SkillLearn:
             writer (EoWriter): The writer that the data will be serialized to.
             data (SkillLearn): The data to serialize.
         """
-        if data._id is None:
-            raise SerializationError("id must be provided.")
-        writer.add_short(data._id)
-        if data._level_requirement is None:
-            raise SerializationError("level_requirement must be provided.")
-        writer.add_char(data._level_requirement)
-        if data._class_requirement is None:
-            raise SerializationError("class_requirement must be provided.")
-        writer.add_char(data._class_requirement)
-        if data._cost is None:
-            raise SerializationError("cost must be provided.")
-        writer.add_int(data._cost)
-        if data._skill_requirements is None:
-            raise SerializationError("skill_requirements must be provided.")
-        if len(data._skill_requirements) != 4:
-            raise SerializationError(f"Expected length of skill_requirements to be exactly 4, got {len(data._skill_requirements)}.")
-        for i in range(4):
-            writer.add_short(data._skill_requirements[i])
-        if data._stat_requirements is None:
-            raise SerializationError("stat_requirements must be provided.")
-        CharacterBaseStats.serialize(writer, data._stat_requirements)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._id is None:
+                raise SerializationError("id must be provided.")
+            writer.add_short(data._id)
+            if data._level_requirement is None:
+                raise SerializationError("level_requirement must be provided.")
+            writer.add_char(data._level_requirement)
+            if data._class_requirement is None:
+                raise SerializationError("class_requirement must be provided.")
+            writer.add_char(data._class_requirement)
+            if data._cost is None:
+                raise SerializationError("cost must be provided.")
+            writer.add_int(data._cost)
+            if data._skill_requirements is None:
+                raise SerializationError("skill_requirements must be provided.")
+            if len(data._skill_requirements) != 4:
+                raise SerializationError(f"Expected length of skill_requirements to be exactly 4, got {len(data._skill_requirements)}.")
+            for i in range(4):
+                writer.add_short(data._skill_requirements[i])
+            if data._stat_requirements is None:
+                raise SerializationError("stat_requirements must be provided.")
+            SkillStatRequirements.serialize(writer, data._stat_requirements)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SkillLearn":
@@ -163,20 +121,20 @@ class SkillLearn:
         Returns:
             SkillLearn: The data to serialize.
         """
-        data: SkillLearn = SkillLearn()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._id = reader.get_short()
-            data._level_requirement = reader.get_char()
-            data._class_requirement = reader.get_char()
-            data._cost = reader.get_int()
-            data._skill_requirements = []
+            id = reader.get_short()
+            level_requirement = reader.get_char()
+            class_requirement = reader.get_char()
+            cost = reader.get_int()
+            skill_requirements = []
             for i in range(4):
-                data._skill_requirements.append(reader.get_short())
-            data._stat_requirements = CharacterBaseStats.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+                skill_requirements.append(reader.get_short())
+            stat_requirements = SkillStatRequirements.deserialize(reader)
+            result = SkillLearn(id=id, level_requirement=level_requirement, class_requirement=class_requirement, cost=cost, skill_requirements=skill_requirements, stat_requirements=stat_requirements)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/skill_stat_requirements.py

@@ -0,0 +1,134 @@
+# 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 SkillStatRequirements:
+    """
+    Stat requirements to learn a skill from a skill master NPC
+    """
+    _byte_size: int = 0
+    _str: int
+    _wis: int
+    _intl: int
+    _agi: int
+    _con: int
+    _cha: int
+
+    def __init__(self, *, str: int, wis: int, intl: int, agi: int, con: int, cha: int):
+        """
+        Create a new instance of SkillStatRequirements.
+
+        Args:
+            str (int): (Value range is 0-64008.)
+            wis (int): (Value range is 0-64008.)
+            intl (int): (Value range is 0-64008.)
+            agi (int): (Value range is 0-64008.)
+            con (int): (Value range is 0-64008.)
+            cha (int): (Value range is 0-64008.)
+        """
+        self._str = str
+        self._wis = wis
+        self._intl = intl
+        self._agi = agi
+        self._con = con
+        self._cha = cha
+
+    @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 str(self) -> int:
+        return self._str
+
+    @property
+    def wis(self) -> int:
+        return self._wis
+
+    @property
+    def intl(self) -> int:
+        return self._intl
+
+    @property
+    def agi(self) -> int:
+        return self._agi
+
+    @property
+    def con(self) -> int:
+        return self._con
+
+    @property
+    def cha(self) -> int:
+        return self._cha
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "SkillStatRequirements") -> None:
+        """
+        Serializes an instance of `SkillStatRequirements` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (SkillStatRequirements): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._str is None:
+                raise SerializationError("str must be provided.")
+            writer.add_short(data._str)
+            if data._wis is None:
+                raise SerializationError("wis must be provided.")
+            writer.add_short(data._wis)
+            if data._intl is None:
+                raise SerializationError("intl must be provided.")
+            writer.add_short(data._intl)
+            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) -> "SkillStatRequirements":
+        """
+        Deserializes an instance of `SkillStatRequirements` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            SkillStatRequirements: The data to serialize.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            str = reader.get_short()
+            wis = reader.get_short()
+            intl = reader.get_short()
+            agi = reader.get_short()
+            con = reader.get_short()
+            cha = reader.get_short()
+            result = SkillStatRequirements(str=str, wis=wis, intl=intl, agi=agi, con=con, cha=cha)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"SkillStatRequirements(byte_size={repr(self._byte_size)}, str={repr(self._str)}, wis={repr(self._wis)}, intl={repr(self._intl)}, agi={repr(self._agi)}, con={repr(self._con)}, cha={repr(self._cha)})"

eolib/protocol/_generated/net/server/spell_error_server_packet.py

@@ -15,6 +15,11 @@ class SpellErrorServerPacket(Packet):
     """
     _byte_size: int = 0
 
+    def __init__(self):
+        """
+        Create a new instance of SpellErrorServerPacket.
+        """
+
     @property
     def byte_size(self) -> int:
         """
@@ -63,9 +68,11 @@ class SpellErrorServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellErrorServerPacket): The data to serialize.
         """
-        old_writer_length: int = len(writer)
-        if len(writer) == old_writer_length:
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
             writer.add_byte(255)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellErrorServerPacket":
@@ -78,14 +85,13 @@ class SpellErrorServerPacket(Packet):
         Returns:
             SpellErrorServerPacket: The data to serialize.
         """
-        data: SpellErrorServerPacket = SpellErrorServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            if reader.position == reader_start_position:
-                reader.get_byte()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reader.get_byte()
+            result = SpellErrorServerPacket()
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/spell_player_server_packet.py

@@ -16,8 +16,19 @@ class SpellPlayerServerPacket(Packet):
     Nearby player raising their arm to cast a spell (vestigial)
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _direction: Direction = None # type: ignore [assignment]
+    _player_id: int
+    _direction: Direction
+
+    def __init__(self, *, player_id: int, direction: Direction):
+        """
+        Create a new instance of SpellPlayerServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            direction (Direction): 
+        """
+        self._player_id = player_id
+        self._direction = direction
 
     @property
     def byte_size(self) -> int:
@@ -31,28 +42,12 @@ class SpellPlayerServerPacket(Packet):
 
     @property
     def player_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._player_id
 
-    @player_id.setter
-    def player_id(self, player_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._player_id = player_id
-
     @property
     def direction(self) -> Direction:
         return self._direction
 
-    @direction.setter
-    def direction(self, direction: Direction) -> None:
-        self._direction = direction
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -91,12 +86,16 @@ class SpellPlayerServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (SpellPlayerServerPacket): The data to serialize.
         """
-        if data._player_id is None:
-            raise SerializationError("player_id must be provided.")
-        writer.add_short(data._player_id)
-        if data._direction is None:
-            raise SerializationError("direction must be provided.")
-        writer.add_char(int(data._direction))
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._player_id is None:
+                raise SerializationError("player_id must be provided.")
+            writer.add_short(data._player_id)
+            if data._direction is None:
+                raise SerializationError("direction must be provided.")
+            writer.add_char(int(data._direction))
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "SpellPlayerServerPacket":
@@ -109,14 +108,14 @@ class SpellPlayerServerPacket(Packet):
         Returns:
             SpellPlayerServerPacket: The data to serialize.
         """
-        data: SpellPlayerServerPacket = SpellPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._direction = Direction(reader.get_char())
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            direction = Direction(reader.get_char())
+            result = SpellPlayerServerPacket(player_id=player_id, direction=direction)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

eolib/protocol/_generated/net/server/spell_reply_server_packet.py

@@ -0,0 +1,133 @@
+# Generated from the eo-protocol XML specification.
+#
+# This file should not be modified.
+# Changes will be lost when code is regenerated.
+
+from ..packet_family import PacketFamily
+from ..packet_action import PacketAction
+from ....serialization_error import SerializationError
+from ....net.packet import Packet
+from .....data.eo_writer import EoWriter
+from .....data.eo_reader import EoReader
+
+class SpellReplyServerPacket(Packet):
+    """
+    Your character self-cast a targetable heal spell
+    """
+    _byte_size: int = 0
+    _spell_id: int
+    _hp: int
+    _tp: int
+
+    def __init__(self, *, spell_id: int, hp: int, tp: int):
+        """
+        Create a new instance of SpellReplyServerPacket.
+
+        Args:
+            spell_id (int): (Value range is 0-64008.)
+            hp (int): (Value range is 0-64008.)
+            tp (int): (Value range is 0-64008.)
+        """
+        self._spell_id = spell_id
+        self._hp = hp
+        self._tp = tp
+
+    @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 spell_id(self) -> int:
+        return self._spell_id
+
+    @property
+    def hp(self) -> int:
+        return self._hp
+
+    @property
+    def tp(self) -> int:
+        return self._tp
+
+    @staticmethod
+    def family() -> PacketFamily:
+        """
+        Returns the packet family associated with this packet.
+
+        Returns:
+            PacketFamily: The packet family associated with this packet.
+        """
+        return PacketFamily.Spell
+
+    @staticmethod
+    def action() -> PacketAction:
+        """
+        Returns the packet action associated with this packet.
+
+        Returns:
+            PacketAction: The packet action associated with this packet.
+        """
+        return PacketAction.Reply
+
+    def write(self, writer):
+        """
+        Serializes and writes this packet to the provided EoWriter.
+
+        Args:
+            writer (EoWriter): the writer that this packet will be written to.
+        """
+        SpellReplyServerPacket.serialize(writer, self)
+
+    @staticmethod
+    def serialize(writer: EoWriter, data: "SpellReplyServerPacket") -> None:
+        """
+        Serializes an instance of `SpellReplyServerPacket` to the provided `EoWriter`.
+
+        Args:
+            writer (EoWriter): The writer that the data will be serialized to.
+            data (SpellReplyServerPacket): The data to serialize.
+        """
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._spell_id is None:
+                raise SerializationError("spell_id must be provided.")
+            writer.add_short(data._spell_id)
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_short(data._hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
+
+    @staticmethod
+    def deserialize(reader: EoReader) -> "SpellReplyServerPacket":
+        """
+        Deserializes an instance of `SpellReplyServerPacket` from the provided `EoReader`.
+
+        Args:
+            reader (EoReader): The writer that the data will be serialized to.
+
+        Returns:
+            SpellReplyServerPacket: The data to serialize.
+        """
+        old_chunked_reading_mode: bool = reader.chunked_reading_mode
+        try:
+            reader_start_position: int = reader.position
+            spell_id = reader.get_short()
+            hp = reader.get_short()
+            tp = reader.get_short()
+            result = SpellReplyServerPacket(spell_id=spell_id, hp=hp, tp=tp)
+            result._byte_size = reader.position - reader_start_position
+            return result
+        finally:
+            reader.chunked_reading_mode = old_chunked_reading_mode
+
+    def __repr__(self):
+        return f"SpellReplyServerPacket(byte_size={repr(self._byte_size)}, spell_id={repr(self._spell_id)}, hp={repr(self._hp)}, tp={repr(self._tp)})"