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

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .drop_npc_record import DropNpcRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,7 +15,16 @@ class DropFile:
     Endless Drop File
     """
     _byte_size: int = 0
-    _npcs: list[DropNpcRecord] = None # type: ignore [assignment]
+    _npcs: tuple[DropNpcRecord, ...]
+
+    def __init__(self, *, npcs: Iterable[DropNpcRecord]):
+        """
+        Create a new instance of DropFile.
+
+        Args:
+            npcs (Iterable[DropNpcRecord]): 
+        """
+        self._npcs = tuple(npcs)
 
     @property
     def byte_size(self) -> int:
@@ -27,13 +37,9 @@ class DropFile:
         return self._byte_size
 
     @property
-    def npcs(self) -> list[DropNpcRecord]:
+    def npcs(self) -> tuple[DropNpcRecord, ...]:
         return self._npcs
 
-    @npcs.setter
-    def npcs(self, npcs: list[DropNpcRecord]) -> None:
-        self._npcs = npcs
-
     @staticmethod
     def serialize(writer: EoWriter, data: "DropFile") -> None:
         """
@@ -64,16 +70,16 @@ class DropFile:
         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 = []
+            npcs = []
             while reader.remaining > 0:
-                data._npcs.append(DropNpcRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                npcs.append(DropNpcRecord.deserialize(reader))
+            result = DropFile(npcs=npcs)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .drop_record import DropRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,9 +15,21 @@ 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]
+    _npc_id: int
+    _drops_count: int
+    _drops: tuple[DropRecord, ...]
+
+    def __init__(self, *, npc_id: int, drops: Iterable[DropRecord]):
+        """
+        Create a new instance of DropNpcRecord.
+
+        Args:
+            npc_id (int): (Value range is 0-64008.)
+            drops (Iterable[DropRecord]): (Length must be 64008 or less.)
+        """
+        self._npc_id = npc_id
+        self._drops = tuple(drops)
+        self._drops_count = len(self._drops)
 
     @property
     def byte_size(self) -> int:
@@ -30,37 +43,12 @@ class DropNpcRecord:
 
     @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.
-        """
+    def drops(self) -> tuple[DropRecord, ...]:
         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:
         """
@@ -98,17 +86,17 @@ class DropNpcRecord:
         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
+            npc_id = reader.get_short()
+            drops_count = reader.get_short()
+            drops = []
+            for i in range(drops_count):
+                drops.append(DropRecord.deserialize(reader))
+            result = DropNpcRecord(npc_id=npc_id, drops=drops)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,10 +12,25 @@ 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]
+    _item_id: int
+    _min_amount: int
+    _max_amount: int
+    _rate: int
+
+    def __init__(self, *, item_id: int, min_amount: int, max_amount: int, rate: int):
+        """
+        Create a new instance of DropRecord.
+
+        Args:
+            item_id (int): (Value range is 0-64008.)
+            min_amount (int): (Value range is 0-16194276.)
+            max_amount (int): (Value range is 0-16194276.)
+            rate (int): Chance (x in 64,000) of the item being dropped (Value range is 0-64008.)
+        """
+        self._item_id = item_id
+        self._min_amount = min_amount
+        self._max_amount = max_amount
+        self._rate = rate
 
     @property
     def byte_size(self) -> int:
@@ -29,72 +44,23 @@ class DropRecord:
 
     @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:
         """
@@ -132,16 +98,16 @@ class DropRecord:
         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
+            item_id = reader.get_short()
+            min_amount = reader.get_three()
+            max_amount = reader.get_three()
+            rate = reader.get_short()
+            result = DropRecord(item_id=item_id, min_amount=min_amount, max_amount=max_amount, rate=rate)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -4,6 +4,7 @@
 # Changes will be lost when code is regenerated.
 
 from __future__ import annotations
+from collections.abc import Iterable
 from .inn_record import InnRecord
 from ....serialization_error import SerializationError
 from .....data.eo_writer import EoWriter
@@ -14,7 +15,16 @@ class InnFile:
     Endless Inn File
     """
     _byte_size: int = 0
-    _inns: list[InnRecord] = None # type: ignore [assignment]
+    _inns: tuple[InnRecord, ...]
+
+    def __init__(self, *, inns: Iterable[InnRecord]):
+        """
+        Create a new instance of InnFile.
+
+        Args:
+            inns (Iterable[InnRecord]): 
+        """
+        self._inns = tuple(inns)
 
     @property
     def byte_size(self) -> int:
@@ -27,13 +37,9 @@ class InnFile:
         return self._byte_size
 
     @property
-    def inns(self) -> list[InnRecord]:
+    def inns(self) -> tuple[InnRecord, ...]:
         return self._inns
 
-    @inns.setter
-    def inns(self, inns: list[InnRecord]) -> None:
-        self._inns = inns
-
     @staticmethod
     def serialize(writer: EoWriter, data: "InnFile") -> None:
         """
@@ -64,16 +70,16 @@ class InnFile:
         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 = []
+            inns = []
             while reader.remaining > 0:
-                data._inns.append(InnRecord.deserialize(reader))
-            data._byte_size = reader.position - reader_start_position
-            return data
+                inns.append(InnRecord.deserialize(reader))
+            result = InnFile(inns=inns)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 

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

@@ -12,10 +12,23 @@ 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]
+    _question_length: int
+    _question: str
+    _answer_length: int
+    _answer: str
+
+    def __init__(self, *, question: str, answer: str):
+        """
+        Create a new instance of InnQuestionRecord.
+
+        Args:
+            question (str): (Length must be 252 or less.)
+            answer (str): (Length must be 252 or less.)
+        """
+        self._question = question
+        self._question_length = len(self._question)
+        self._answer = answer
+        self._answer_length = len(self._answer)
 
     @property
     def byte_size(self) -> int:
@@ -29,38 +42,12 @@ class InnQuestionRecord:
 
     @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:
         """
@@ -102,16 +89,16 @@ class InnQuestionRecord:
         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
+            question_length = reader.get_char()
+            question = reader.get_fixed_string(question_length, False)
+            answer_length = reader.get_char()
+            answer = reader.get_fixed_string(answer_length, False)
+            result = InnQuestionRecord(question=question, answer=answer)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode