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

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

@@ -15,7 +15,16 @@ class CitizenRequestServerPacket(Packet):
     Reply to requesting sleeping at an inn
     """
     _byte_size: int = 0
-    _cost: int = None # type: ignore [assignment]
+    _cost: int
+
+    def __init__(self, *, cost: int):
+        """
+        Create a new instance of CitizenRequestServerPacket.
+
+        Args:
+            cost (int): (Value range is 0-4097152080.)
+        """
+        self._cost = cost
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class CitizenRequestServerPacket(Packet):
 
     @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
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -100,13 +97,13 @@ class CitizenRequestServerPacket(Packet):
         Returns:
             CitizenRequestServerPacket: The data to serialize.
         """
-        data: CitizenRequestServerPacket = CitizenRequestServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._cost = reader.get_int()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            cost = reader.get_int()
+            result = CitizenRequestServerPacket(cost=cost)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,8 +15,19 @@ class ConnectionPlayerServerPacket(Packet):
     Ping request
     """
     _byte_size: int = 0
-    _seq1: int = None # type: ignore [assignment]
-    _seq2: int = None # type: ignore [assignment]
+    _seq1: int
+    _seq2: int
+
+    def __init__(self, *, seq1: int, seq2: int):
+        """
+        Create a new instance of ConnectionPlayerServerPacket.
+
+        Args:
+            seq1 (int): (Value range is 0-64008.)
+            seq2 (int): (Value range is 0-252.)
+        """
+        self._seq1 = seq1
+        self._seq2 = seq2
 
     @property
     def byte_size(self) -> int:
@@ -30,36 +41,12 @@ class ConnectionPlayerServerPacket(Packet):
 
     @property
     def seq1(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._seq1
 
-    @seq1.setter
-    def seq1(self, seq1: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._seq1 = seq1
-
     @property
     def seq2(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._seq2
 
-    @seq2.setter
-    def seq2(self, seq2: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._seq2 = seq2
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -120,14 +107,14 @@ class ConnectionPlayerServerPacket(Packet):
         Returns:
             ConnectionPlayerServerPacket: The data to serialize.
         """
-        data: ConnectionPlayerServerPacket = ConnectionPlayerServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._seq1 = reader.get_short()
-            data._seq2 = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            seq1 = reader.get_short()
+            seq2 = reader.get_char()
+            result = ConnectionPlayerServerPacket(seq1=seq1, seq2=seq2)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -14,9 +14,22 @@ class DialogEntry:
     An entry in a quest dialog
     """
     _byte_size: int = 0
-    _entry_type: DialogEntryType = None # type: ignore [assignment]
-    _entry_type_data: 'DialogEntry.EntryTypeData' = None
-    _line: str = None # type: ignore [assignment]
+    _entry_type: DialogEntryType
+    _entry_type_data: 'DialogEntry.EntryTypeData'
+    _line: str
+
+    def __init__(self, *, entry_type: DialogEntryType, entry_type_data: 'DialogEntry.EntryTypeData' = None, line: str):
+        """
+        Create a new instance of DialogEntry.
+
+        Args:
+            entry_type (DialogEntryType): 
+            entry_type_data (DialogEntry.EntryTypeData): Data associated with the `entry_type` field.
+            line (str): 
+        """
+        self._entry_type = entry_type
+        self._entry_type_data = entry_type_data
+        self._line = line
 
     @property
     def byte_size(self) -> int:
@@ -32,29 +45,17 @@ class DialogEntry:
     def entry_type(self) -> DialogEntryType:
         return self._entry_type
 
-    @entry_type.setter
-    def entry_type(self, entry_type: DialogEntryType) -> None:
-        self._entry_type = entry_type
-
     @property
     def entry_type_data(self) -> 'DialogEntry.EntryTypeData':
         """
-        DialogEntry.EntryTypeData: Gets or sets the data associated with the `entry_type` field.
+        DialogEntry.EntryTypeData: Data associated with the `entry_type` field.
         """
         return self._entry_type_data
 
-    @entry_type_data.setter
-    def entry_type_data(self, entry_type_data: 'DialogEntry.EntryTypeData') -> None:
-        self._entry_type_data = entry_type_data
-
     @property
     def line(self) -> str:
         return self._line
 
-    @line.setter
-    def line(self, line: str) -> None:
-        self._line = line
-
     @staticmethod
     def serialize(writer: EoWriter, data: "DialogEntry") -> None:
         """
@@ -90,16 +91,17 @@ class DialogEntry:
         Returns:
             DialogEntry: The data to serialize.
         """
-        data: DialogEntry = DialogEntry()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._entry_type = DialogEntryType(reader.get_short())
-            if data._entry_type == DialogEntryType.Link:
-                data._entry_type_data = DialogEntry.EntryTypeDataLink.deserialize(reader)
-            data._line = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            entry_type = DialogEntryType(reader.get_short())
+            entry_type_data: DialogEntry.EntryTypeData = None
+            if entry_type == DialogEntryType.Link:
+                entry_type_data = DialogEntry.EntryTypeDataLink.deserialize(reader)
+            line = reader.get_string()
+            result = DialogEntry(entry_type=entry_type, entry_type_data=entry_type_data, line=line)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -116,7 +118,16 @@ class DialogEntry:
         Data associated with entry_type value DialogEntryType.Link
         """
         _byte_size: int = 0
-        _link_id: int = None # type: ignore [assignment]
+        _link_id: int
+
+        def __init__(self, *, link_id: int):
+            """
+            Create a new instance of DialogEntry.EntryTypeDataLink.
+
+            Args:
+                link_id (int): (Value range is 0-64008.)
+            """
+            self._link_id = link_id
 
         @property
         def byte_size(self) -> int:
@@ -130,20 +141,8 @@ class DialogEntry:
 
         @property
         def link_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._link_id
 
-        @link_id.setter
-        def link_id(self, link_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._link_id = link_id
-
         @staticmethod
         def serialize(writer: EoWriter, data: "DialogEntry.EntryTypeDataLink") -> None:
             """
@@ -172,13 +171,13 @@ class DialogEntry:
             Returns:
                 DialogEntry.EntryTypeDataLink: The data to serialize.
             """
-            data: DialogEntry.EntryTypeDataLink = DialogEntry.EntryTypeDataLink()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._link_id = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                link_id = reader.get_short()
+                result = DialogEntry.EntryTypeDataLink(link_id=link_id)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,8 +12,19 @@ class DialogQuestEntry:
     An entry in the quest switcher
     """
     _byte_size: int = 0
-    _quest_id: int = None # type: ignore [assignment]
-    _quest_name: str = None # type: ignore [assignment]
+    _quest_id: int
+    _quest_name: str
+
+    def __init__(self, *, quest_id: int, quest_name: str):
+        """
+        Create a new instance of DialogQuestEntry.
+
+        Args:
+            quest_id (int): (Value range is 0-64008.)
+            quest_name (str): 
+        """
+        self._quest_id = quest_id
+        self._quest_name = quest_name
 
     @property
     def byte_size(self) -> int:
@@ -27,28 +38,12 @@ class DialogQuestEntry:
 
     @property
     def quest_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._quest_id
 
-    @quest_id.setter
-    def quest_id(self, quest_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._quest_id = quest_id
-
     @property
     def quest_name(self) -> str:
         return self._quest_name
 
-    @quest_name.setter
-    def quest_name(self, quest_name: str) -> None:
-        self._quest_name = quest_name
-
     @staticmethod
     def serialize(writer: EoWriter, data: "DialogQuestEntry") -> None:
         """
@@ -80,14 +75,14 @@ class DialogQuestEntry:
         Returns:
             DialogQuestEntry: The data to serialize.
         """
-        data: DialogQuestEntry = DialogQuestEntry()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._quest_id = reader.get_short()
-            data._quest_name = reader.get_string()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            quest_id = reader.get_short()
+            quest_name = reader.get_string()
+            result = DialogQuestEntry(quest_id=quest_id, quest_name=quest_name)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,7 +15,16 @@ class DoorCloseServerPacket(Packet):
     Reply to trying to open a locked door
     """
     _byte_size: int = 0
-    _key: int = None # type: ignore [assignment]
+    _key: int
+
+    def __init__(self, *, key: int):
+        """
+        Create a new instance of DoorCloseServerPacket.
+
+        Args:
+            key (int): (Value range is 0-252.)
+        """
+        self._key = key
 
     @property
     def byte_size(self) -> int:
@@ -29,20 +38,8 @@ class DoorCloseServerPacket(Packet):
 
     @property
     def key(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._key
 
-    @key.setter
-    def key(self, key: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._key = key
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -100,13 +97,13 @@ class DoorCloseServerPacket(Packet):
         Returns:
             DoorCloseServerPacket: The data to serialize.
         """
-        data: DoorCloseServerPacket = DoorCloseServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._key = reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            key = reader.get_char()
+            result = DoorCloseServerPacket(key=key)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -16,7 +16,16 @@ class DoorOpenServerPacket(Packet):
     Nearby door opening
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
+    _coords: Coords
+
+    def __init__(self, *, coords: Coords):
+        """
+        Create a new instance of DoorOpenServerPacket.
+
+        Args:
+            coords (Coords): The official server erroneously encodes the Y coordinate as a short. The official client reads each coordinate as a char.
+        """
+        self._coords = coords
 
     @property
     def byte_size(self) -> int:
@@ -30,12 +39,12 @@ class DoorOpenServerPacket(Packet):
 
     @property
     def coords(self) -> Coords:
+        """
+        The official server erroneously encodes the Y coordinate as a short.
+        The official client reads each coordinate as a char.
+        """
         return self._coords
 
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -79,7 +88,6 @@ class DoorOpenServerPacket(Packet):
             if data._coords is None:
                 raise SerializationError("coords must be provided.")
             Coords.serialize(writer, data._coords)
-            writer.add_char(0)
         finally:
             writer.string_sanitization_mode = old_string_sanitization_mode
 
@@ -94,14 +102,13 @@ class DoorOpenServerPacket(Packet):
         Returns:
             DoorOpenServerPacket: The data to serialize.
         """
-        data: DoorOpenServerPacket = DoorOpenServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            reader.get_char()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            coords = Coords.deserialize(reader)
+            result = DoorOpenServerPacket(coords=coords)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -15,10 +15,25 @@ class EffectAdminServerPacket(Packet):
     Nearby character taking spike damage
     """
     _byte_size: int = 0
-    _player_id: int = None # type: ignore [assignment]
-    _hp_percentage: int = None # type: ignore [assignment]
-    _died: bool = None # type: ignore [assignment]
-    _damage: int = None # type: ignore [assignment]
+    _player_id: int
+    _hp_percentage: int
+    _died: bool
+    _damage: int
+
+    def __init__(self, *, player_id: int, hp_percentage: int, died: bool, damage: int):
+        """
+        Create a new instance of EffectAdminServerPacket.
+
+        Args:
+            player_id (int): (Value range is 0-64008.)
+            hp_percentage (int): (Value range is 0-252.)
+            died (bool): 
+            damage (int): (Value range is 0-16194276.)
+        """
+        self._player_id = player_id
+        self._hp_percentage = hp_percentage
+        self._died = died
+        self._damage = damage
 
     @property
     def byte_size(self) -> int:
@@ -32,60 +47,20 @@ class EffectAdminServerPacket(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 hp_percentage(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._hp_percentage
 
-    @hp_percentage.setter
-    def hp_percentage(self, hp_percentage: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._hp_percentage = hp_percentage
-
     @property
     def died(self) -> bool:
         return self._died
 
-    @died.setter
-    def died(self, died: bool) -> None:
-        self._died = died
-
     @property
     def damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._damage
 
-    @damage.setter
-    def damage(self, damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._damage = damage
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -152,16 +127,16 @@ class EffectAdminServerPacket(Packet):
         Returns:
             EffectAdminServerPacket: The data to serialize.
         """
-        data: EffectAdminServerPacket = EffectAdminServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._player_id = reader.get_short()
-            data._hp_percentage = reader.get_char()
-            data._died = reader.get_char() != 0
-            data._damage = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            player_id = reader.get_short()
+            hp_percentage = reader.get_char()
+            died = reader.get_char() != 0
+            damage = reader.get_three()
+            result = EffectAdminServerPacket(player_id=player_id, hp_percentage=hp_percentage, died=died, damage=damage)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -3,9 +3,11 @@
 # This file should not be modified.
 # Changes will be lost when code is regenerated.
 
+from __future__ import annotations
+from collections.abc import Iterable
+from .tile_effect import TileEffect
 from ..packet_family import PacketFamily
 from ..packet_action import PacketAction
-from ...coords import Coords
 from ....serialization_error import SerializationError
 from ....net.packet import Packet
 from .....data.eo_writer import EoWriter
@@ -13,11 +15,19 @@ from .....data.eo_reader import EoReader
 
 class EffectAgreeServerPacket(Packet):
     """
-    Map tile effect
+    Effects playing on nearby tiles
     """
     _byte_size: int = 0
-    _coords: Coords = None # type: ignore [assignment]
-    _effect_id: int = None # type: ignore [assignment]
+    _effects: tuple[TileEffect, ...]
+
+    def __init__(self, *, effects: Iterable[TileEffect]):
+        """
+        Create a new instance of EffectAgreeServerPacket.
+
+        Args:
+            effects (Iterable[TileEffect]): 
+        """
+        self._effects = tuple(effects)
 
     @property
     def byte_size(self) -> int:
@@ -30,28 +40,8 @@ class EffectAgreeServerPacket(Packet):
         return self._byte_size
 
     @property
-    def coords(self) -> Coords:
-        return self._coords
-
-    @coords.setter
-    def coords(self, coords: Coords) -> None:
-        self._coords = coords
-
-    @property
-    def effect_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        return self._effect_id
-
-    @effect_id.setter
-    def effect_id(self, effect_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._effect_id = effect_id
+    def effects(self) -> tuple[TileEffect, ...]:
+        return self._effects
 
     @staticmethod
     def family() -> PacketFamily:
@@ -93,12 +83,10 @@ class EffectAgreeServerPacket(Packet):
         """
         old_string_sanitization_mode: bool = writer.string_sanitization_mode
         try:
-            if data._coords is None:
-                raise SerializationError("coords must be provided.")
-            Coords.serialize(writer, data._coords)
-            if data._effect_id is None:
-                raise SerializationError("effect_id must be provided.")
-            writer.add_short(data._effect_id)
+            if data._effects is None:
+                raise SerializationError("effects must be provided.")
+            for i in range(len(data._effects)):
+                TileEffect.serialize(writer, data._effects[i])
         finally:
             writer.string_sanitization_mode = old_string_sanitization_mode
 
@@ -113,16 +101,18 @@ class EffectAgreeServerPacket(Packet):
         Returns:
             EffectAgreeServerPacket: The data to serialize.
         """
-        data: EffectAgreeServerPacket = EffectAgreeServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._coords = Coords.deserialize(reader)
-            data._effect_id = reader.get_short()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            effects_length = int(reader.remaining / 4)
+            effects = []
+            for i in range(effects_length):
+                effects.append(TileEffect.deserialize(reader))
+            result = EffectAgreeServerPacket(effects=effects)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
     def __repr__(self):
-        return f"EffectAgreeServerPacket(byte_size={repr(self._byte_size)}, coords={repr(self._coords)}, effect_id={repr(self._effect_id)})"
+        return f"EffectAgreeServerPacket(byte_size={repr(self._byte_size)}, effects={repr(self._effects)})"