PyREUser3 0.4.0__tar.gz → 0.5.0__tar.gz

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.4.0
+Version: 0.5.0
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/PyREUser3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyREUser3
-Version: 0.4.0
+Version: 0.5.0
 Summary: Pure Python tools for converting RE Engine .user.3 files to and from JSON.
 Author: Egg Targaryen
 License-Expression: MIT

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyREUser3"
-version = "0.4.0"
+version = "0.5.0"
 description = "Pure Python tools for converting RE Engine .user.3 files to and from JSON."
 readme = "docs/PYPI.md"
 requires-python = ">=3.9"

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/export/fields.py

@@ -74,7 +74,7 @@ class ExporterFieldParserMixin:
             return {"ref_instance_id": reader.read_s32()}
         if t in ("String", "Resource"):
             return read_len_utf16(reader)
-        if t == "C8":
+        if t in ("C8", "RuntimeType"):
             return read_len_c8(reader)
         if t in ("Guid", "GameObjectRef", "Uri"):
             return read_guid_like(reader)
@@ -230,7 +230,7 @@ class ExporterFieldParserMixin:
             t = field.field_type
             if field.is_array:
                 pos += 4
-            elif t in ("String", "Resource", "C8"):
+            elif t in ("String", "Resource", "C8", "RuntimeType"):
                 pos += 4
             elif t in ("Object", "UserData"):
                 pos += 4
@@ -250,7 +250,9 @@ class ExporterFieldParserMixin:
                 pos += max(field.size, 0)
         return max(pos, 1)
 
-    def _parse_instance(self, reader: BinaryReader, class_hash: int) -> dict[str, Any]:
+    def _parse_instance(
+        self, reader: BinaryReader, class_hash: int, crc: int | None = None
+    ) -> dict[str, Any]:
         """Parse instance.
 
         The method keeps parsing, metadata lookup, and JSON shaping explicit so incomplete
@@ -259,6 +261,7 @@ class ExporterFieldParserMixin:
         Args:
             reader (BinaryReader): BinaryReader positioned at the value to parse.
             class_hash (int): RE_RSZ type hash for a class.
+            crc (int | None): Optional CRC used to choose among same-hash layout variants.
 
         Returns:
             dict[str, Any]: JSON-compatible dictionary for API or conversion callers.
@@ -266,7 +269,7 @@ class ExporterFieldParserMixin:
         Raises:
             ParseError: Binary data did not match the expected .user.3 or RSZ layout.
         """
-        cls = self.typedb.get_class(class_hash)
+        cls = self.typedb.get_class(class_hash, crc)
         if cls is None:
             raise ParseError(f"class hash 0x{class_hash:08x} not found in schema")
         out: dict[str, Any] = {"_class": cls.name, "fields": {}}

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/export/metadata.py

@@ -337,7 +337,9 @@ class ExporterMetadataMixin:
         if typedb is None or not enum_lookup:
             return
 
-        for class_def in typedb.classes.values():
+        iter_classes = getattr(typedb, "iter_classes", None)
+        class_defs = iter_classes() if callable(iter_classes) else typedb.classes.values()
+        for class_def in class_defs:
             field_map = self.class_field_fixed_types.setdefault(class_def.name, {})
             for field in class_def.fields:
                 if field.field_type != "Enum":

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/export/tree.py

@@ -245,6 +245,17 @@ class ExporterTreeMixin:
                 }
             }
 
+        if inst.get("unparsed"):
+            class_name = inst.get("class_name", "Unknown Class")
+            class_name = self._normalize_to_fixed_enum_type(class_name)
+            return {
+                class_name: {
+                    "ref_instance_id": idx,
+                    "unparsed": True,
+                    "reason": inst.get("reason", "unparsed"),
+                }
+            }
+
         data = inst.get("data", {})
         class_name = data.get("_class", inst.get("class_name", "Unknown Class"))
         class_name = self._normalize_to_fixed_enum_type(class_name)

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/export/user3.py

@@ -56,11 +56,12 @@ class ExporterUser3ParserMixin:
                 reader.seek(usr_header["userdata_info_tbl"])
                 for idx in range(usr_header["userdata_count"]):
                     class_hash = reader.read_u32()
-                    _crc = reader.read_u32()
+                    crc = reader.read_u32()
                     path_offset = reader.read_u64()
+                    class_def = self.typedb.get_class(class_hash, crc)
                     class_name = (
-                        self.typedb.get_class(class_hash).name
-                        if self.typedb.get_class(class_hash)
+                        class_def.name
+                        if class_def
                         else "Unknown Class"
                     )
                     header_userdata_infos.append(
@@ -112,7 +113,7 @@ class ExporterUser3ParserMixin:
             # depend on these indexes remaining stable.
             class_hash = reader.read_u32()
             crc = reader.read_u32()
-            class_def = self.typedb.get_class(class_hash)
+            class_def = self.typedb.get_class(class_hash, crc)
             instance_infos.append(
                 {
                     "index": idx,
@@ -175,7 +176,7 @@ class ExporterUser3ParserMixin:
                     }
                 )
                 continue
-            cls = self.typedb.get_class(class_hash)
+            cls = self.typedb.get_class(class_hash, int(info["crc"]))
             if cls is None:
                 # Follow schema field layout exactly so alignment, padding, and unknown
                 # data remain binary-compatible.
@@ -198,7 +199,14 @@ class ExporterUser3ParserMixin:
             start_pos = reader.tell()
             try:
                 parsed_instances.append(
-                    {"index": idx, "data": self._parse_instance(reader, class_hash)}
+                    {
+                        "index": idx,
+                        "data": self._parse_instance(
+                            reader,
+                            class_hash,
+                            crc=int(info["crc"]),
+                        ),
+                    }
                 )
             except Exception as exc:
                 # Treat each file independently so one malformed resource is reported

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/pack/plan.py

@@ -95,16 +95,23 @@ class PackerPlanMixin:
             class_name = entry.get("_class")
             if not isinstance(class_name, str) or not class_name:
                 raise PackError(f"instance {idx} is missing _class")
-            class_hash = self.typedb.name_to_hash.get(class_name)
-            if class_hash is None:
+            declared_crc = self._parse_optional_u32(entry.get("_crc"))
+            fields = entry.get("fields", {})
+            field_names = (
+                {key for key in fields if isinstance(key, str)}
+                if isinstance(fields, dict)
+                else None
+            )
+            resolved = self.typedb.get_class_for_fields(
+                class_name,
+                field_names=field_names,
+                crc=declared_crc,
+            )
+            if resolved is None:
                 raise PackError(
                     f"class not found in schema for instance {idx}: {class_name}"
                 )
-            class_def = self.typedb.get_class(class_hash)
-            if class_def is None:
-                raise PackError(
-                    f"class hash not found in schema for instance {idx}: {class_name}"
-                )
+            class_hash, class_def = resolved
             self._validate_declared_hash(idx, entry, class_hash, class_def.crc)
             self.instances[idx] = InstanceSpec(
                 class_hash=class_hash, class_def=class_def
@@ -363,12 +370,15 @@ class PackerPlanMixin:
             PackError: JSON input could not be represented safely as .user.3 binary data.
         """
         class_name, fields = self._unwrap_node(node, expected_class)
-        class_hash = self.typedb.name_to_hash.get(class_name)
-        if class_hash is None:
+        field_names = (
+            {key for key in fields if isinstance(key, str)}
+            if isinstance(fields, dict)
+            else None
+        )
+        resolved = self.typedb.get_class_for_fields(class_name, field_names=field_names)
+        if resolved is None:
             raise PackError(f"class not found in schema: {class_name}")
-        class_def = self.typedb.get_class(class_hash)
-        if class_def is None:
-            raise PackError(f"class hash not found in schema: {class_name}")
+        class_hash, class_def = resolved
 
         spec = InstanceSpec(class_hash=class_hash, class_def=class_def)
         spec.fields = self._prepare_fields(class_def, fields)
@@ -602,7 +612,7 @@ class PackerPlanMixin:
             return False
         if field_def.field_type in {"F32", "F64"}:
             return 0.0
-        if field_def.field_type in {"String", "Resource", "C8"}:
+        if field_def.field_type in {"String", "Resource", "C8", "RuntimeType"}:
             return ""
         if field_def.field_type in {"Guid", "GameObjectRef", "Uri"}:
             return "00000000-0000-0000-0000-000000000000"

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/pack/writer.py

@@ -215,8 +215,8 @@ class PackerWriterMixin:
             writer.write_struct("<I", len(raw) // 2)
             writer.write(raw)
             return
-        if t == "C8":
-            # C8 strings store UTF-8 byte length and keep a trailing null byte in the binary stream.
+        if t in {"C8", "RuntimeType"}:
+            # C8-style strings store UTF-8 byte length and keep a trailing null byte in the binary stream.
             writer.align(4)
             raw = f"{value or ''}\x00".encode("utf-8")
             writer.write_struct("<I", len(raw))

{pyreuser3-0.4.0 → pyreuser3-0.5.0}/pyreuser3/schema.py

@@ -10,6 +10,11 @@ import json
 from dataclasses import dataclass
 from pathlib import Path
 
+BTABLE_ORDER_LIST_CLASS_HASH = 0xD081F6C1
+BTABLE_ORDER_LIST_NAME = "ace.btable.user_data.BTableOrderList"
+BTABLE_ORDER_LIST_LEGACY_CRC = 0x6C85037C
+BTABLE_ORDER_LIST_LEGACY_FIELDS = ("_OperatorFactories", "_CommandFactories")
+
 
 def murmur3_32(data: bytes, seed: int = 0xFFFFFFFF) -> int:
     """Compute the MurmurHash3 variant used by RE_RSZ type names.
@@ -101,7 +106,7 @@ class ClassDef:
 
 
 class TypeDB:
-    """Index RE_RSZ class definitions by hash and by name for parser and packer lookups.
+    """Index RE_RSZ class definitions by hash, CRC, and name for parser and packer lookups.
     """
 
     def __init__(self, classes: dict[int, ClassDef]):
@@ -114,6 +119,11 @@ class TypeDB:
             None. The method performs its documented side effect in place and raises on invalid input.
         """
         self.classes = classes
+        self.class_variants: dict[tuple[int, int], ClassDef] = {
+            (class_hash, class_def.crc & 0xFFFFFFFF): class_def
+            for class_hash, class_def in classes.items()
+        }
+        self._add_builtin_class_variants()
         # Preserve the exported JSON structure so external scripts and hand-edited files
         # remain compatible across workflows.
         self.name_to_hash = {c.name: h for h, c in classes.items()}
@@ -164,17 +174,99 @@ class TypeDB:
             )
         return cls(classes)
 
-    def get_class(self, class_hash: int) -> ClassDef | None:
+    def _add_builtin_class_variants(self) -> None:
+        """Register known CRC-specific layouts omitted by some public schema dumps."""
+        base_class = self.classes.get(BTABLE_ORDER_LIST_CLASS_HASH)
+        if base_class is None or base_class.name != BTABLE_ORDER_LIST_NAME:
+            return
+
+        fields_by_name = {field.name: field for field in base_class.fields}
+        legacy_fields = [
+            fields_by_name[name]
+            for name in BTABLE_ORDER_LIST_LEGACY_FIELDS
+            if name in fields_by_name
+        ]
+        if len(legacy_fields) != len(BTABLE_ORDER_LIST_LEGACY_FIELDS):
+            return
+
+        self.class_variants.setdefault(
+            (BTABLE_ORDER_LIST_CLASS_HASH, BTABLE_ORDER_LIST_LEGACY_CRC),
+            ClassDef(
+                name=base_class.name,
+                crc=BTABLE_ORDER_LIST_LEGACY_CRC,
+                fields=legacy_fields,
+            ),
+        )
+
+    def get_class(self, class_hash: int, crc: int | None = None) -> ClassDef | None:
         """Get class.
 
         Args:
             class_hash (int): RE_RSZ type hash for a class.
+            crc (int | None): Optional CRC used to choose among same-hash layout variants.
 
         Returns:
             ClassDef | None: Matching class definition when the schema contains the requested identifier.
         """
+        if crc is not None:
+            class_def = self.class_variants.get((class_hash, crc & 0xFFFFFFFF))
+            if class_def is not None:
+                return class_def
         return self.classes.get(class_hash)
 
+    def get_class_for_fields(
+        self,
+        class_name: str,
+        field_names: set[str] | None = None,
+        crc: int | None = None,
+    ) -> tuple[int, ClassDef] | None:
+        """Resolve a class by name, optionally preferring a CRC or exact field layout."""
+        class_hash = self.name_to_hash.get(class_name)
+        if class_hash is None:
+            return None
+        if crc is not None:
+            class_def = self.class_variants.get((class_hash, crc & 0xFFFFFFFF))
+            if class_def is not None:
+                return class_hash, class_def
+        if field_names is not None:
+            exact_matches: list[ClassDef] = []
+            for (variant_hash, _variant_crc), class_def in self.class_variants.items():
+                if variant_hash != class_hash or class_def.name != class_name:
+                    continue
+                variant_fields = {field.name or "unnamed" for field in class_def.fields}
+                if variant_fields == field_names:
+                    exact_matches.append(class_def)
+            if len(exact_matches) == 1:
+                class_def = exact_matches[0]
+                if crc is not None and (class_def.crc & 0xFFFFFFFF) != (
+                    crc & 0xFFFFFFFF
+                ):
+                    return (
+                        class_hash,
+                        ClassDef(
+                            name=class_def.name,
+                            crc=crc & 0xFFFFFFFF,
+                            fields=class_def.fields,
+                        ),
+                    )
+                return class_hash, class_def
+        class_def = self.get_class(class_hash)
+        if class_def is None:
+            return None
+        return class_hash, class_def
+
+    def iter_classes(self) -> list[ClassDef]:
+        """Return base classes and CRC-specific variants without duplicate objects."""
+        out: list[ClassDef] = []
+        seen: set[int] = set()
+        for class_def in list(self.classes.values()) + list(self.class_variants.values()):
+            marker = id(class_def)
+            if marker in seen:
+                continue
+            seen.add(marker)
+            out.append(class_def)
+        return out
+
     def resolve_struct_hash(self, original_type: str) -> int | None:
         """Resolve struct hash.
 

pyreuser3-0.5.0/tests/test_enum_binary.py

@@ -0,0 +1,221 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from pyreuser3.core import BinaryReader, RSZ_MAGIC, USR_MAGIC, enum_storage_type_from_size
+from pyreuser3.export.fields import ExporterFieldParserMixin
+from pyreuser3.pack.models import BinaryWriter
+from pyreuser3.pack.plan import PackerPlanMixin
+from pyreuser3.pack.writer import PackerWriterMixin
+from pyreuser3.schema import FieldDef, TypeDB
+
+
+class EnumFieldParser(ExporterFieldParserMixin):
+    def __init__(self, storage_type: str | None = None):
+        self.storage_type = storage_type
+
+    def _resolve_enum_storage_type(self, field: FieldDef) -> str:
+        return self.storage_type or enum_storage_type_from_size(field.size)
+
+
+class EnumFieldWriter(PackerWriterMixin):
+    def __init__(self):
+        self.enum_underlying_types = {"via.motion.AxisDirection": "U8"}
+        self.member_lookup = {"via.motion.AxisDirection": {"Right": 2}}
+
+    @staticmethod
+    def _to_s32(value: int) -> int:
+        u32 = value & 0xFFFFFFFF
+        return u32 if u32 < 0x80000000 else u32 - 0x100000000
+
+
+class EmptyBinaryWriter(PackerWriterMixin):
+    def __init__(self):
+        self.instances = [None]
+        self.user_magic = USR_MAGIC
+        self.rsz_magic = RSZ_MAGIC
+
+
+class PlanDefaults(PackerPlanMixin):
+    pass
+
+
+class EnumBinaryTests(unittest.TestCase):
+    def test_build_binary_uses_shared_alignment_helper(self):
+        writer_mixin = EmptyBinaryWriter()
+
+        data = writer_mixin._build_binary([])
+
+        self.assertEqual(data[:4], USR_MAGIC.to_bytes(4, "little"))
+        self.assertEqual(data[0x30:0x34], RSZ_MAGIC.to_bytes(4, "little"))
+
+    def test_enum_reader_uses_schema_size_fallback(self):
+        parser = EnumFieldParser()
+        reader = BinaryReader(b"\x02abcdef")
+        field = FieldDef(
+            name="v2_LegDirection",
+            field_type="Enum",
+            original_type="via.motion.AxisDirection",
+            size=1,
+            align=1,
+            is_array=False,
+        )
+
+        self.assertEqual(parser._parse_field_value(reader, field), 2)
+        self.assertEqual(reader.tell(), 1)
+
+    def test_enum_reader_uses_il2cpp_underlying_type(self):
+        parser = EnumFieldParser("U8")
+        reader = BinaryReader(b"\x02\x00\x00\x00")
+        field = FieldDef(
+            name="v2_LegDirection",
+            field_type="Enum",
+            original_type="via.motion.AxisDirection",
+            size=4,
+            align=4,
+            is_array=False,
+        )
+
+        self.assertEqual(parser._parse_field_value(reader, field), 2)
+        self.assertEqual(reader.tell(), 1)
+
+    def test_enum_writer_uses_il2cpp_underlying_type_for_labels(self):
+        writer_mixin = EnumFieldWriter()
+        writer = BinaryWriter()
+        field = FieldDef(
+            name="v2_LegDirection",
+            field_type="Enum",
+            original_type="via.motion.AxisDirection",
+            size=1,
+            align=1,
+            is_array=False,
+        )
+
+        writer_mixin._write_scalar(writer, field, "Right")
+        self.assertEqual(bytes(writer.data), b"\x02")
+
+    def test_runtime_type_reader_uses_c8_string_layout(self):
+        parser = EnumFieldParser()
+        reader = BinaryReader(b"\x04\x00\x00\x00abc\x00tail")
+        field = FieldDef(
+            name="_OrderType",
+            field_type="RuntimeType",
+            original_type="System.Type",
+            size=4,
+            align=4,
+            is_array=False,
+        )
+
+        self.assertEqual(parser._parse_field_value(reader, field), "abc")
+        self.assertEqual(reader.tell(), 8)
+
+    def test_runtime_type_writer_uses_c8_string_layout(self):
+        writer_mixin = EnumFieldWriter()
+        writer = BinaryWriter()
+        field = FieldDef(
+            name="_OrderType",
+            field_type="RuntimeType",
+            original_type="System.Type",
+            size=4,
+            align=4,
+            is_array=False,
+        )
+
+        writer_mixin._write_scalar(writer, field, "abc")
+
+        self.assertEqual(bytes(writer.data), b"\x04\x00\x00\x00abc\x00")
+
+    def test_runtime_type_default_is_empty_string(self):
+        field = FieldDef(
+            name="_OrderType",
+            field_type="RuntimeType",
+            original_type="System.Type",
+            size=4,
+            align=4,
+            is_array=False,
+        )
+
+        self.assertEqual(PlanDefaults()._default_value(field), "")
+
+    def test_typedb_selects_btable_order_list_crc_variant(self):
+        schema = {
+            "d081f6c1": {
+                "crc": "15afce2d",
+                "name": "ace.btable.user_data.BTableOrderList",
+                "fields": [
+                    {
+                        "name": "_OperatorFactories",
+                        "type": "Object",
+                        "original_type": "ace.btable.cOperatorFactory",
+                        "size": 4,
+                        "align": 4,
+                        "array": True,
+                    },
+                    {
+                        "name": "_CommandFactories",
+                        "type": "Object",
+                        "original_type": "ace.btable.cCommandFactory",
+                        "size": 4,
+                        "align": 4,
+                        "array": True,
+                    },
+                    {
+                        "name": "_OperatorHashList",
+                        "type": "U64",
+                        "original_type": "System.UInt64",
+                        "size": 8,
+                        "align": 8,
+                        "array": True,
+                    },
+                    {
+                        "name": "_CommandHashList",
+                        "type": "U64",
+                        "original_type": "System.UInt64",
+                        "size": 8,
+                        "align": 8,
+                        "array": True,
+                    },
+                ],
+            }
+        }
+        with tempfile.TemporaryDirectory() as tmpdir:
+            schema_path = Path(tmpdir) / "schema.json"
+            schema_path.write_text(json.dumps(schema), encoding="utf-8")
+
+            typedb = TypeDB.load(schema_path)
+
+        current = typedb.get_class(0xD081F6C1, 0x15AFCE2D)
+        legacy = typedb.get_class(0xD081F6C1, 0x6C85037C)
+        resolved = typedb.get_class_for_fields(
+            "ace.btable.user_data.BTableOrderList",
+            field_names={"_OperatorFactories", "_CommandFactories"},
+        )
+        crc_alias = typedb.get_class_for_fields(
+            "ace.btable.user_data.BTableOrderList",
+            field_names={
+                "_OperatorFactories",
+                "_CommandFactories",
+                "_OperatorHashList",
+                "_CommandHashList",
+            },
+            crc=0x12345678,
+        )
+
+        self.assertIsNotNone(current)
+        self.assertEqual(len(current.fields), 4)
+        self.assertIsNotNone(legacy)
+        self.assertEqual(legacy.crc, 0x6C85037C)
+        self.assertEqual([field.name for field in legacy.fields], [
+            "_OperatorFactories",
+            "_CommandFactories",
+        ])
+        self.assertIsNotNone(resolved)
+        self.assertEqual(resolved[1].crc, 0x6C85037C)
+        self.assertIsNotNone(crc_alias)
+        self.assertEqual(crc_alias[1].crc, 0x12345678)
+        self.assertEqual(len(crc_alias[1].fields), 4)
+
+
+if __name__ == "__main__":
+    unittest.main()

pyreuser3-0.4.0/tests/test_enum_binary.py

@@ -1,92 +0,0 @@
-import unittest
-
-from pyreuser3.core import BinaryReader, RSZ_MAGIC, USR_MAGIC, enum_storage_type_from_size
-from pyreuser3.export.fields import ExporterFieldParserMixin
-from pyreuser3.pack.models import BinaryWriter
-from pyreuser3.pack.writer import PackerWriterMixin
-from pyreuser3.schema import FieldDef
-
-
-class EnumFieldParser(ExporterFieldParserMixin):
-    def __init__(self, storage_type: str | None = None):
-        self.storage_type = storage_type
-
-    def _resolve_enum_storage_type(self, field: FieldDef) -> str:
-        return self.storage_type or enum_storage_type_from_size(field.size)
-
-
-class EnumFieldWriter(PackerWriterMixin):
-    def __init__(self):
-        self.enum_underlying_types = {"via.motion.AxisDirection": "U8"}
-        self.member_lookup = {"via.motion.AxisDirection": {"Right": 2}}
-
-    @staticmethod
-    def _to_s32(value: int) -> int:
-        u32 = value & 0xFFFFFFFF
-        return u32 if u32 < 0x80000000 else u32 - 0x100000000
-
-
-class EmptyBinaryWriter(PackerWriterMixin):
-    def __init__(self):
-        self.instances = [None]
-        self.user_magic = USR_MAGIC
-        self.rsz_magic = RSZ_MAGIC
-
-
-class EnumBinaryTests(unittest.TestCase):
-    def test_build_binary_uses_shared_alignment_helper(self):
-        writer_mixin = EmptyBinaryWriter()
-
-        data = writer_mixin._build_binary([])
-
-        self.assertEqual(data[:4], USR_MAGIC.to_bytes(4, "little"))
-        self.assertEqual(data[0x30:0x34], RSZ_MAGIC.to_bytes(4, "little"))
-
-    def test_enum_reader_uses_schema_size_fallback(self):
-        parser = EnumFieldParser()
-        reader = BinaryReader(b"\x02abcdef")
-        field = FieldDef(
-            name="v2_LegDirection",
-            field_type="Enum",
-            original_type="via.motion.AxisDirection",
-            size=1,
-            align=1,
-            is_array=False,
-        )
-
-        self.assertEqual(parser._parse_field_value(reader, field), 2)
-        self.assertEqual(reader.tell(), 1)
-
-    def test_enum_reader_uses_il2cpp_underlying_type(self):
-        parser = EnumFieldParser("U8")
-        reader = BinaryReader(b"\x02\x00\x00\x00")
-        field = FieldDef(
-            name="v2_LegDirection",
-            field_type="Enum",
-            original_type="via.motion.AxisDirection",
-            size=4,
-            align=4,
-            is_array=False,
-        )
-
-        self.assertEqual(parser._parse_field_value(reader, field), 2)
-        self.assertEqual(reader.tell(), 1)
-
-    def test_enum_writer_uses_il2cpp_underlying_type_for_labels(self):
-        writer_mixin = EnumFieldWriter()
-        writer = BinaryWriter()
-        field = FieldDef(
-            name="v2_LegDirection",
-            field_type="Enum",
-            original_type="via.motion.AxisDirection",
-            size=1,
-            align=1,
-            is_array=False,
-        )
-
-        writer_mixin._write_scalar(writer, field, "Right")
-        self.assertEqual(bytes(writer.data), b"\x02")
-
-
-if __name__ == "__main__":
-    unittest.main()