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

eolib/protocol/_generated/pub/enf_record.py

@@ -14,28 +14,78 @@ class EnfRecord:
     Record of NPC data in an Endless NPC File
     """
     _byte_size: int = 0
-    _name_length: int = None # type: ignore [assignment]
-    _name: str = None # type: ignore [assignment]
-    _graphic_id: int = None # type: ignore [assignment]
-    _race: int = None # type: ignore [assignment]
-    _boss: bool = None # type: ignore [assignment]
-    _child: bool = None # type: ignore [assignment]
-    _type: NpcType = None # type: ignore [assignment]
-    _behavior_id: int = None # type: ignore [assignment]
-    _hp: int = None # type: ignore [assignment]
-    _tp: int = None # type: ignore [assignment]
-    _min_damage: int = None # type: ignore [assignment]
-    _max_damage: int = None # type: ignore [assignment]
-    _accuracy: int = None # type: ignore [assignment]
-    _evade: int = None # type: ignore [assignment]
-    _armor: int = None # type: ignore [assignment]
-    _return_damage: int = None # type: ignore [assignment]
-    _element: Element = None # type: ignore [assignment]
-    _element_damage: int = None # type: ignore [assignment]
-    _element_weakness: Element = None # type: ignore [assignment]
-    _element_weakness_damage: int = None # type: ignore [assignment]
-    _level: int = None # type: ignore [assignment]
-    _experience: int = None # type: ignore [assignment]
+    _name_length: int
+    _name: str
+    _graphic_id: int
+    _race: int
+    _boss: bool
+    _child: bool
+    _type: NpcType
+    _behavior_id: int
+    _hp: int
+    _tp: int
+    _min_damage: int
+    _max_damage: int
+    _accuracy: int
+    _evade: int
+    _armor: int
+    _return_damage: int
+    _element: Element
+    _element_damage: int
+    _element_weakness: Element
+    _element_weakness_damage: int
+    _level: int
+    _experience: int
+
+    def __init__(self, *, name: str, graphic_id: int, race: int, boss: bool, child: bool, type: NpcType, behavior_id: int, hp: int, tp: int, min_damage: int, max_damage: int, accuracy: int, evade: int, armor: int, return_damage: int, element: Element, element_damage: int, element_weakness: Element, element_weakness_damage: int, level: int, experience: int):
+        """
+        Create a new instance of EnfRecord.
+
+        Args:
+            name (str): (Length must be 252 or less.)
+            graphic_id (int): (Value range is 0-64008.)
+            race (int): (Value range is 0-252.)
+            boss (bool): 
+            child (bool): 
+            type (NpcType): 
+            behavior_id (int): (Value range is 0-64008.)
+            hp (int): (Value range is 0-16194276.)
+            tp (int): (Value range is 0-64008.)
+            min_damage (int): (Value range is 0-64008.)
+            max_damage (int): (Value range is 0-64008.)
+            accuracy (int): (Value range is 0-64008.)
+            evade (int): (Value range is 0-64008.)
+            armor (int): (Value range is 0-64008.)
+            return_damage (int): (Value range is 0-252.)
+            element (Element): 
+            element_damage (int): (Value range is 0-64008.)
+            element_weakness (Element): 
+            element_weakness_damage (int): (Value range is 0-64008.)
+            level (int): (Value range is 0-252.)
+            experience (int): (Value range is 0-16194276.)
+        """
+        self._name = name
+        self._name_length = len(self._name)
+        self._graphic_id = graphic_id
+        self._race = race
+        self._boss = boss
+        self._child = child
+        self._type = type
+        self._behavior_id = behavior_id
+        self._hp = hp
+        self._tp = tp
+        self._min_damage = min_damage
+        self._max_damage = max_damage
+        self._accuracy = accuracy
+        self._evade = evade
+        self._armor = armor
+        self._return_damage = return_damage
+        self._element = element
+        self._element_damage = element_damage
+        self._element_weakness = element_weakness
+        self._element_weakness_damage = element_weakness_damage
+        self._level = level
+        self._experience = experience
 
     @property
     def byte_size(self) -> int:
@@ -49,301 +99,88 @@ class EnfRecord:
 
     @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 graphic_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._graphic_id
 
-    @graphic_id.setter
-    def graphic_id(self, graphic_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._graphic_id = graphic_id
-
     @property
     def race(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._race
 
-    @race.setter
-    def race(self, race: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._race = race
-
     @property
     def boss(self) -> bool:
         return self._boss
 
-    @boss.setter
-    def boss(self, boss: bool) -> None:
-        self._boss = boss
-
     @property
     def child(self) -> bool:
         return self._child
 
-    @child.setter
-    def child(self, child: bool) -> None:
-        self._child = child
-
     @property
     def type(self) -> NpcType:
         return self._type
 
-    @type.setter
-    def type(self, type: NpcType) -> None:
-        self._type = type
-
     @property
     def behavior_id(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._behavior_id
 
-    @behavior_id.setter
-    def behavior_id(self, behavior_id: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._behavior_id = behavior_id
-
     @property
     def hp(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._hp
 
-    @hp.setter
-    def hp(self, hp: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._hp = hp
-
     @property
     def tp(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._tp
 
-    @tp.setter
-    def tp(self, tp: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._tp = tp
-
     @property
     def min_damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._min_damage
 
-    @min_damage.setter
-    def min_damage(self, min_damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._min_damage = min_damage
-
     @property
     def max_damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._max_damage
 
-    @max_damage.setter
-    def max_damage(self, max_damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._max_damage = max_damage
-
     @property
     def accuracy(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._accuracy
 
-    @accuracy.setter
-    def accuracy(self, accuracy: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._accuracy = accuracy
-
     @property
     def evade(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._evade
 
-    @evade.setter
-    def evade(self, evade: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._evade = evade
-
     @property
     def armor(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._armor
 
-    @armor.setter
-    def armor(self, armor: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._armor = armor
-
     @property
     def return_damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._return_damage
 
-    @return_damage.setter
-    def return_damage(self, return_damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._return_damage = return_damage
-
     @property
     def element(self) -> Element:
         return self._element
 
-    @element.setter
-    def element(self, element: Element) -> None:
-        self._element = element
-
     @property
     def element_damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._element_damage
 
-    @element_damage.setter
-    def element_damage(self, element_damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._element_damage = element_damage
-
     @property
     def element_weakness(self) -> Element:
         return self._element_weakness
 
-    @element_weakness.setter
-    def element_weakness(self, element_weakness: Element) -> None:
-        self._element_weakness = element_weakness
-
     @property
     def element_weakness_damage(self) -> int:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
         return self._element_weakness_damage
 
-    @element_weakness_damage.setter
-    def element_weakness_damage(self, element_weakness_damage: int) -> None:
-        """
-        Note:
-          - Value range is 0-64008.
-        """
-        self._element_weakness_damage = element_weakness_damage
-
     @property
     def level(self) -> int:
-        """
-        Note:
-          - Value range is 0-252.
-        """
         return self._level
 
-    @level.setter
-    def level(self, level: int) -> None:
-        """
-        Note:
-          - Value range is 0-252.
-        """
-        self._level = level
-
     @property
     def experience(self) -> int:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
         return self._experience
 
-    @experience.setter
-    def experience(self, experience: int) -> None:
-        """
-        Note:
-          - Value range is 0-16194276.
-        """
-        self._experience = experience
-
     @staticmethod
     def serialize(writer: EoWriter, data: "EnfRecord") -> None:
         """
@@ -353,74 +190,78 @@ class EnfRecord:
             writer (EoWriter): The writer that the data will be serialized to.
             data (EnfRecord): 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._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._graphic_id is None:
-            raise SerializationError("graphic_id must be provided.")
-        writer.add_short(data._graphic_id)
-        if data._race is None:
-            raise SerializationError("race must be provided.")
-        writer.add_char(data._race)
-        if data._boss is None:
-            raise SerializationError("boss must be provided.")
-        writer.add_short(1 if data._boss else 0)
-        if data._child is None:
-            raise SerializationError("child must be provided.")
-        writer.add_short(1 if data._child else 0)
-        if data._type is None:
-            raise SerializationError("type must be provided.")
-        writer.add_short(int(data._type))
-        if data._behavior_id is None:
-            raise SerializationError("behavior_id must be provided.")
-        writer.add_short(data._behavior_id)
-        if data._hp is None:
-            raise SerializationError("hp must be provided.")
-        writer.add_three(data._hp)
-        if data._tp is None:
-            raise SerializationError("tp must be provided.")
-        writer.add_short(data._tp)
-        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._element is None:
-            raise SerializationError("element must be provided.")
-        writer.add_short(int(data._element))
-        if data._element_damage is None:
-            raise SerializationError("element_damage must be provided.")
-        writer.add_short(data._element_damage)
-        if data._element_weakness is None:
-            raise SerializationError("element_weakness must be provided.")
-        writer.add_short(int(data._element_weakness))
-        if data._element_weakness_damage is None:
-            raise SerializationError("element_weakness_damage must be provided.")
-        writer.add_short(data._element_weakness_damage)
-        if data._level is None:
-            raise SerializationError("level must be provided.")
-        writer.add_char(data._level)
-        if data._experience is None:
-            raise SerializationError("experience must be provided.")
-        writer.add_three(data._experience)
+        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._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._graphic_id is None:
+                raise SerializationError("graphic_id must be provided.")
+            writer.add_short(data._graphic_id)
+            if data._race is None:
+                raise SerializationError("race must be provided.")
+            writer.add_char(data._race)
+            if data._boss is None:
+                raise SerializationError("boss must be provided.")
+            writer.add_short(1 if data._boss else 0)
+            if data._child is None:
+                raise SerializationError("child must be provided.")
+            writer.add_short(1 if data._child else 0)
+            if data._type is None:
+                raise SerializationError("type must be provided.")
+            writer.add_short(int(data._type))
+            if data._behavior_id is None:
+                raise SerializationError("behavior_id must be provided.")
+            writer.add_short(data._behavior_id)
+            if data._hp is None:
+                raise SerializationError("hp must be provided.")
+            writer.add_three(data._hp)
+            if data._tp is None:
+                raise SerializationError("tp must be provided.")
+            writer.add_short(data._tp)
+            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._element is None:
+                raise SerializationError("element must be provided.")
+            writer.add_short(int(data._element))
+            if data._element_damage is None:
+                raise SerializationError("element_damage must be provided.")
+            writer.add_short(data._element_damage)
+            if data._element_weakness is None:
+                raise SerializationError("element_weakness must be provided.")
+            writer.add_short(int(data._element_weakness))
+            if data._element_weakness_damage is None:
+                raise SerializationError("element_weakness_damage must be provided.")
+            writer.add_short(data._element_weakness_damage)
+            if data._level is None:
+                raise SerializationError("level must be provided.")
+            writer.add_char(data._level)
+            if data._experience is None:
+                raise SerializationError("experience must be provided.")
+            writer.add_three(data._experience)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "EnfRecord":
@@ -433,34 +274,34 @@ class EnfRecord:
         Returns:
             EnfRecord: The data to serialize.
         """
-        data: EnfRecord = EnfRecord()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._name_length = reader.get_char()
-            data._name = reader.get_fixed_string(data._name_length, False)
-            data._graphic_id = reader.get_short()
-            data._race = reader.get_char()
-            data._boss = reader.get_short() != 0
-            data._child = reader.get_short() != 0
-            data._type = NpcType(reader.get_short())
-            data._behavior_id = reader.get_short()
-            data._hp = reader.get_three()
-            data._tp = reader.get_short()
-            data._min_damage = reader.get_short()
-            data._max_damage = reader.get_short()
-            data._accuracy = reader.get_short()
-            data._evade = reader.get_short()
-            data._armor = reader.get_short()
-            data._return_damage = reader.get_char()
-            data._element = Element(reader.get_short())
-            data._element_damage = reader.get_short()
-            data._element_weakness = Element(reader.get_short())
-            data._element_weakness_damage = reader.get_short()
-            data._level = reader.get_char()
-            data._experience = reader.get_three()
-            data._byte_size = reader.position - reader_start_position
-            return data
+            name_length = reader.get_char()
+            name = reader.get_fixed_string(name_length, False)
+            graphic_id = reader.get_short()
+            race = reader.get_char()
+            boss = reader.get_short() != 0
+            child = reader.get_short() != 0
+            type = NpcType(reader.get_short())
+            behavior_id = reader.get_short()
+            hp = reader.get_three()
+            tp = reader.get_short()
+            min_damage = reader.get_short()
+            max_damage = reader.get_short()
+            accuracy = reader.get_short()
+            evade = reader.get_short()
+            armor = reader.get_short()
+            return_damage = reader.get_char()
+            element = Element(reader.get_short())
+            element_damage = reader.get_short()
+            element_weakness = Element(reader.get_short())
+            element_weakness_damage = reader.get_short()
+            level = reader.get_char()
+            experience = reader.get_three()
+            result = EnfRecord(name=name, graphic_id=graphic_id, race=race, boss=boss, child=child, type=type, behavior_id=behavior_id, hp=hp, tp=tp, min_damage=min_damage, max_damage=max_damage, accuracy=accuracy, evade=evade, armor=armor, return_damage=return_damage, element=element, element_damage=element_damage, element_weakness=element_weakness, element_weakness_damage=element_weakness_damage, level=level, experience=experience)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode