Added the Entity Metadata type

* Modified the conf.py sphinx configuration file to ignore the custom fields used in the Entity Metadata type
* Added the Entity Metadata type to the documentation
* Added `scripts` to the .codeclimate.yml ignore list

Author: LiteApplication

.codeclimate.yml

@@ -31,6 +31,11 @@ checks:
   return-statements:
     enabled: false
 
+
+
 exclude_patterns:
   - "tests/**"
   - ".github/**"
+  # The scripts directory is only there to provide quick scripts to generate things that are in the actual code
+  # They don't need testing as they are not meant to be used outside the developpment process
+  - "scripts/**"

docs/api/types/entity_metadata.rst

@@ -0,0 +1,10 @@
+Entity Metadata
+======================
+
+This is the documentation for the NBT type used in Minecraft's network protocol.
+
+
+
+
+.. automodule:: mcproto.types.entity
+   :no-undoc-members:

docs/api/types/index.rst

@@ -1,12 +1,12 @@
-.. api/types documentation master file
+.. Types Documentation
 
-=======================
-API Types Documentation
-=======================
+Types Documentation
+==================================
 
-Welcome to the API Types documentation! This documentation provides information about the various types used in the API.
+This folder contains the documentation for various types used in the project.
 
 .. toctree::
     :maxdepth: 2
 
     nbt.rst
+    entity_metadata.rst

docs/api/types/nbt.rst

@@ -1,6 +1,9 @@
 NBT Format
 ==========
 
+This is the documentation for the NBT type used in Minecraft's network protocol.
+
+
 .. automodule:: mcproto.types.nbt
     :members:
     :show-inheritance:

docs/conf.py

@@ -12,10 +12,13 @@
 import sys
 import datetime
 from pathlib import Path
+from typing import Any
 
 from packaging.version import parse as parse_version
 from typing_extensions import override
 
+from mcproto.types.entity.metadata import _ProxyEntityMetadataEntry, _DefaultEntityMetadataEntry
+
 if sys.version_info >= (3, 11):
     from tomllib import load as toml_parse
 else:
@@ -117,6 +120,21 @@
     "exclude-members": "__dict__,__weakref__",
 }
 
+
+def autodoc_skip_member(app: Any, what: str, name: str, obj: Any, skip: bool, options: Any) -> bool:
+    """Skip EntityMetadataEntry class fields as they are already documented in the docstring."""
+    if isinstance(obj, type) and (
+        issubclass(obj, _ProxyEntityMetadataEntry) or issubclass(obj, _DefaultEntityMetadataEntry)
+    ):
+        return True
+    return skip
+
+
+def setup(app: Any) -> None:
+    """Set up the Sphinx app."""
+    app.connect("autodoc-skip-member", autodoc_skip_member)
+
+
 # -- sphinx.ext.autosectionlabel ---------------
 
 # Automatically generate section labels:

mcproto/types/entity/__init__.py

@@ -0,0 +1,300 @@
+from mcproto.types.entity.generated import (
+    EntityEM,
+    InteractionEM,
+    DisplayEM,
+    BlockDisplayEM,
+    ItemDisplayEM,
+    TextDisplayEM,
+    ThrownItemProjectileEM,
+    ThrownEggEM,
+    ThrownEnderPearlEM,
+    ThrownExperienceBottleEM,
+    ThrownPotionEM,
+    ThrownSnowballEM,
+    EyeOfEnderEM,
+    FallingBlockEM,
+    AreaEffectCloudEM,
+    FishingHookEM,
+    AbstractArrowEM,
+    ArrowEM,
+    SpectralArrowEM,
+    ThrownTridentEM,
+    AbstractVehicleEM,
+    BoatEM,
+    ChestBoatEM,
+    AbstractMinecartEM,
+    MinecartEM,
+    AbstractMinecartContainerEM,
+    MinecartHopperEM,
+    MinecartChestEM,
+    MinecartFurnaceEM,
+    MinecartTNTEM,
+    MinecartSpawnerEM,
+    MinecartCommandBlockEM,
+    EndCrystalEM,
+    DragonFireballEM,
+    SmallFireballEM,
+    FireballEM,
+    WitherSkullEM,
+    FireworkRocketEM,
+    ItemFrameEM,
+    GlowingItemFrameEM,
+    PaintingEM,
+    ItemEntityEM,
+    LivingEntityEM,
+    PlayerEM,
+    ArmorStandEM,
+    MobEM,
+    AmbientCreatureEM,
+    BatEM,
+    PathfinderMobEM,
+    WaterAnimalEM,
+    SquidEM,
+    DolphinEM,
+    AbstractFishEM,
+    CodEM,
+    PufferFishEM,
+    SalmonEM,
+    TropicalFishEM,
+    TadpoleEM,
+    AgeableMobEM,
+    AnimalEM,
+    SnifferEM,
+    AbstractHorseEM,
+    HorseEM,
+    ZombieHorseEM,
+    SkeletonHorseEM,
+    CamelEM,
+    ChestedHorseEM,
+    DonkeyEM,
+    LlamaEM,
+    TraderLlamaEM,
+    MuleEM,
+    AxolotlEM,
+    BeeEM,
+    FoxEM,
+    FrogEM,
+    OcelotEM,
+    PandaEM,
+    PigEM,
+    RabbitEM,
+    TurtleEM,
+    PolarBearEM,
+    ChickenEM,
+    CowEM,
+    MooshroomEM,
+    HoglinEM,
+    SheepEM,
+    StriderEM,
+    GoatEM,
+    TameableAnimalEM,
+    CatEM,
+    WolfEM,
+    ParrotEM,
+    AbstractVillagerEM,
+    VillagerEM,
+    WanderingTraderEM,
+    AbstractGolemEM,
+    IronGolemEM,
+    SnowGolemEM,
+    ShulkerEM,
+    MonsterEM,
+    BasePiglinEM,
+    PiglinEM,
+    PiglinBruteEM,
+    BlazeEM,
+    CreeperEM,
+    EndermiteEM,
+    GiantEM,
+    GuardianEM,
+    ElderGuardianEM,
+    SilverfishEM,
+    RaiderEM,
+    AbstractIllagerEM,
+    VindicatorEM,
+    PillagerEM,
+    SpellcasterIllagerEM,
+    EvokerEM,
+    IllusionerEM,
+    RavagerEM,
+    WitchEM,
+    EvokerFangsEM,
+    VexEM,
+    AbstractSkeletonEM,
+    SkeletonEM,
+    WitherSkeletonEM,
+    StrayEM,
+    SpiderEM,
+    WardenEM,
+    WitherEM,
+    ZoglinEM,
+    ZombieEM,
+    ZombieVillagerEM,
+    HuskEM,
+    DrownedEM,
+    ZombifiedPiglinEM,
+    EndermanEM,
+    EnderDragonEM,
+    FlyingEM,
+    GhastEM,
+    PhantomEM,
+    SlimeEM,
+    LlamaSpitEM,
+    PrimedTntEM,
+)
+
+######################################################################
+# This file is automatically generated by the entity generator script.
+#     You can modify it by changing what you want in the script.
+######################################################################
+
+from mcproto.types.entity.enums import Direction, Pose, SnifferState, DragonPhase
+
+__all__ = [
+    "EntityEM",
+    "InteractionEM",
+    "DisplayEM",
+    "BlockDisplayEM",
+    "ItemDisplayEM",
+    "TextDisplayEM",
+    "ThrownItemProjectileEM",
+    "ThrownEggEM",
+    "ThrownEnderPearlEM",
+    "ThrownExperienceBottleEM",
+    "ThrownPotionEM",
+    "ThrownSnowballEM",
+    "EyeOfEnderEM",
+    "FallingBlockEM",
+    "AreaEffectCloudEM",
+    "FishingHookEM",
+    "AbstractArrowEM",
+    "ArrowEM",
+    "SpectralArrowEM",
+    "ThrownTridentEM",
+    "AbstractVehicleEM",
+    "BoatEM",
+    "ChestBoatEM",
+    "AbstractMinecartEM",
+    "MinecartEM",
+    "AbstractMinecartContainerEM",
+    "MinecartHopperEM",
+    "MinecartChestEM",
+    "MinecartFurnaceEM",
+    "MinecartTNTEM",
+    "MinecartSpawnerEM",
+    "MinecartCommandBlockEM",
+    "EndCrystalEM",
+    "DragonFireballEM",
+    "SmallFireballEM",
+    "FireballEM",
+    "WitherSkullEM",
+    "FireworkRocketEM",
+    "ItemFrameEM",
+    "GlowingItemFrameEM",
+    "PaintingEM",
+    "ItemEntityEM",
+    "LivingEntityEM",
+    "PlayerEM",
+    "ArmorStandEM",
+    "MobEM",
+    "AmbientCreatureEM",
+    "BatEM",
+    "PathfinderMobEM",
+    "WaterAnimalEM",
+    "SquidEM",
+    "DolphinEM",
+    "AbstractFishEM",
+    "CodEM",
+    "PufferFishEM",
+    "SalmonEM",
+    "TropicalFishEM",
+    "TadpoleEM",
+    "AgeableMobEM",
+    "AnimalEM",
+    "SnifferEM",
+    "AbstractHorseEM",
+    "HorseEM",
+    "ZombieHorseEM",
+    "SkeletonHorseEM",
+    "CamelEM",
+    "ChestedHorseEM",
+    "DonkeyEM",
+    "LlamaEM",
+    "TraderLlamaEM",
+    "MuleEM",
+    "AxolotlEM",
+    "BeeEM",
+    "FoxEM",
+    "FrogEM",
+    "OcelotEM",
+    "PandaEM",
+    "PigEM",
+    "RabbitEM",
+    "TurtleEM",
+    "PolarBearEM",
+    "ChickenEM",
+    "CowEM",
+    "MooshroomEM",
+    "HoglinEM",
+    "SheepEM",
+    "StriderEM",
+    "GoatEM",
+    "TameableAnimalEM",
+    "CatEM",
+    "WolfEM",
+    "ParrotEM",
+    "AbstractVillagerEM",
+    "VillagerEM",
+    "WanderingTraderEM",
+    "AbstractGolemEM",
+    "IronGolemEM",
+    "SnowGolemEM",
+    "ShulkerEM",
+    "MonsterEM",
+    "BasePiglinEM",
+    "PiglinEM",
+    "PiglinBruteEM",
+    "BlazeEM",
+    "CreeperEM",
+    "EndermiteEM",
+    "GiantEM",
+    "GuardianEM",
+    "ElderGuardianEM",
+    "SilverfishEM",
+    "RaiderEM",
+    "AbstractIllagerEM",
+    "VindicatorEM",
+    "PillagerEM",
+    "SpellcasterIllagerEM",
+    "EvokerEM",
+    "IllusionerEM",
+    "RavagerEM",
+    "WitchEM",
+    "EvokerFangsEM",
+    "VexEM",
+    "AbstractSkeletonEM",
+    "SkeletonEM",
+    "WitherSkeletonEM",
+    "StrayEM",
+    "SpiderEM",
+    "WardenEM",
+    "WitherEM",
+    "ZoglinEM",
+    "ZombieEM",
+    "ZombieVillagerEM",
+    "HuskEM",
+    "DrownedEM",
+    "ZombifiedPiglinEM",
+    "EndermanEM",
+    "EnderDragonEM",
+    "FlyingEM",
+    "GhastEM",
+    "PhantomEM",
+    "SlimeEM",
+    "LlamaSpitEM",
+    "PrimedTntEM",
+    "Direction",
+    "Pose",
+    "SnifferState",
+    "DragonPhase",
+]

mcproto/types/entity/enums.py

@@ -0,0 +1,92 @@
+from enum import IntEnum
+
+
+class Direction(IntEnum):
+    """Represents a direction in the world."""
+
+    DOWN = 0
+    """Towards the negative y-axis. (-y)"""
+    UP = 1
+    """Towards the positive y-axis. (+y)"""
+    NORTH = 2
+    """Towards the negative z-axis. (-z)"""
+    SOUTH = 3
+    """Towards the positive z-axis. (+z)"""
+    WEST = 4
+    """Towards the negative x-axis. (-x)"""
+    EAST = 5
+    """Towards the positive x-axis. (+x)"""
+
+
+class Pose(IntEnum):
+    """Represents a pose of an entity."""
+
+    STANDING = 0
+    """The entity is standing. (default)"""
+    FALL_FLYING = 1
+    """The entity is falling or flying."""
+    SLEEPING = 2
+    """The entity is sleeping. (e.g. in a bed)"""
+    SWIMMING = 3
+    """The entity is swimming."""
+    SPIN_ATTACK = 4
+    """The entity is performing a spin attack (with a riptide trident)."""
+    SNEAKING = 5
+    """The entity is sneaking."""
+    LONG_JUMPING = 6
+    """The entity is long jumping."""
+    DYING = 7
+    """The entity is dying"""
+    CROAKING = 8
+    """The entity is croaking. (a frog)"""
+    USING_TONGUE = 9
+    """The entity is using its tongue. (a frog)"""
+    SITTING = 10
+    """The entity is sitting. (e.g. a pet)"""
+    ROARING = 11
+    """The entity is roaring. (a warden)"""
+    SNIFFING = 12
+    """The entity is sniffing."""
+    EMERGING = 13
+    """The entity is emerging from the ground. (a warden)"""
+    DIGGING = 14
+    """The entity is digging."""
+
+
+class SnifferState(IntEnum):
+    """Represents the state of a sniffer."""
+
+    IDLING = 0
+    FEELING_HAPPY = 1
+    SCENTING = 2
+    SNIFFING = 3
+    SEARCHING = 4
+    DIGGING = 5
+    RISING = 6
+
+
+class DragonPhase(IntEnum):
+    """Represents the state the ender dragon is in."""
+
+    CIRCLING = 0
+    """The dragon is circling around the portal."""
+    STRAFING = 1
+    """The dragon is strafing the player."""
+    FLYING_TO_PORTAL = 2
+    """The dragon is flying to the portal."""
+    LANDING_ON_PORTAL = 3
+    """The dragon is landing on the portal. (perching)"""
+    TAKING_OFF_FROM_PORTAL = 4
+    """The dragon is taking off from the portal."""
+    LANDED_BREATH_ATTACK = 5
+    """The dragon has landed and is performing a breath attack."""
+    LANDED_LOOKING_FOR_PLAYER = 6
+    """The dragon has landed and is looking for the player."""
+    LANDED_ROAR = 7
+    """The dragon has landed and is roaring."""
+    CHARGING_PLAYER = 8
+    """The dragon is charging at the player."""
+    FLYING_TO_PORTAL_TO_DIE = 9
+    """The dragon is flying to the portal to die."""
+    HOVERING_NO_AI = 10
+    """The dragon is hovering in place with no AI. (default)"""

mcproto/types/entity/generated.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+from typing import List, Dict, Union, cast
+from pathlib import Path
+import subprocess
+import sys
+
+from scripts.entity_generator_data import ENTITY_DATA, EntityData, Field
+
+BASE_CLASS = '''
+class {name}({base}):
+    """{class_description}
+
+    {fields_docstring}
+
+    """
+
+    {fields}
+
+    __slots__ = ()
+
+'''
+
+
+ENTRY_FIELD = """{name}: {input} = entry({type}, {default})"""
+INPUT_UNAVAILABLE = """ClassVar[{input}]"""
+# Mark as ignore by sphinx
+PROXY_FIELD = """{name}: {input} = proxy({target}, {type}, {kwargs})"""
+
+FIELD_DESCRIPTION = """:param {name}: {description}
+:type {name}: {input}, optional, default: {default}"""
+PROXY_DESCRIPTION = """:param {name}: {description} (this affects :attr:`{target}`)
+:type {name}: {input}, optional"""
+UNAVAILABLE_PREFIX = "_"
+TYPE_SUFFIX = "EME"  # EntityMetadataEntry
+NAME_SUFFIX = "EM"  # EntityMetadata
+
+
+FILE_HEADER = """
+######################################################################
+# This file is automatically generated by the entity generator script.
+#     You can modify it by changing what you want in the script.
+######################################################################
+
+from mcproto.types.entity.enums import {enums}
+
+__all__ = [
+    {all}
+]
+"""
+
+BASE_FILE = """
+from __future__ import annotations
+from typing import ClassVar, Any
+{header}
+
+from mcproto.types.entity.metadata import (
+    proxy,
+    entry,
+    EntityMetadata,
+)
+from mcproto.types.entity.metadata_types import {types}
+from mcproto.types.slot import Slot
+from mcproto.types.chat import TextComponent
+from mcproto.types.nbt import NBTag, EndNBT
+from mcproto.types.vec3 import Position
+from mcproto.types.uuid import UUID
+
+{classes}
+"""
+INIT_FILE = """
+from mcproto.types.entity.generated import {generated}
+{header}
+"""
+
+FILE_PATH = "mcproto/types/entity/generated.py"
+INIT_PATH = "mcproto/types/entity/__init__.py"
+
+# This dictionary holds the decumentation for each entity to allow it to be appended to inherited classes
+main_doc_repo: dict[str, str] = {}
+
+
+def generate_class(entity_description: EntityData) -> tuple[str, set[str], set[str]]:  # noqa: PLR0912
+    """Generate a class from the entity description.
+
+    :param entity_description: The entity description to generate the class from.
+
+    :return: The generated string for the class, a set of used enums, and a set of used types.
+    """
+    field_docs: list[str] = []
+    fields: list[str] = []
+    used_enums: set[str] = set()
+    used_types: set[str] = set()
+    name = entity_description["name"]
+    name = cast(str, name) + NAME_SUFFIX  # EntityMetadata
+    base = entity_description.get("base", "EntityMetadata")
+    base = cast(str, base)
+    if base != "EntityMetadata":
+        base += NAME_SUFFIX
+    for variable in entity_description["fields"]:
+        variable = cast(Field, variable)
+        v_type = cast(str, variable["type"])
+        v_name = cast(str, variable["name"])
+        v_default = variable["default"]
+        v_input = variable["input"]
+        v_description = variable.get("description", "")
+        v_proxy = cast(List[Dict[str, Union[type, str, int]]], variable.get("proxy", []))
+        v_available = variable.get("available", True)
+        v_enum = variable.get("enum", False)
+
+        if v_enum:
+            used_enums.add(v_type)
+            v_default = f"{v_type}.{v_default}"
+
+        v_type = v_type + TYPE_SUFFIX
+        used_types.add(v_type)
+
+        if not v_available:
+            v_name = UNAVAILABLE_PREFIX + v_name
+
+        if isinstance(v_input, type):
+            v_input = v_input.__name__
+        v_input = cast(str, v_input)
+
+        if v_input == "str":
+            v_default = f'"{v_default}"'
+
+        if v_available:
+            if v_description:
+                if v_enum or not v_input.startswith(("str", "tuple", "float", "int", "bool")):
+                    v_default_desc = f":attr:`{v_default}`"
+                    v_input_desc = f":class:`{v_input}`"
+                else:
+                    v_default_desc = v_default
+                    v_input_desc = v_input
+
+                field_docs.append(
+                    FIELD_DESCRIPTION.format(
+                        name=v_name, description=v_description, input=v_input_desc, default=v_default_desc
+                    )
+                )
+        else:
+            v_input = INPUT_UNAVAILABLE.format(input=v_input)
+
+        fields.append(
+            ENTRY_FIELD.format(
+                name=v_name,
+                input=v_input,
+                type=v_type,
+                default=v_default,
+            )
+        )
+        for proxy_field in v_proxy:
+            proxy_name = cast(str, proxy_field["name"])
+            proxy_type = cast(str, proxy_field["type"])
+            proxy_input = proxy_field.get("input", int)
+            proxy_description = proxy_field.get("description", "")
+            proxy_target = v_name
+
+            if isinstance(proxy_input, type):
+                proxy_input = proxy_input.__name__  # convert the str type to "str" ...
+
+            used_types.add(proxy_type)
+
+            proxy_kwargs = ""
+            for k, v in proxy_field.items():
+                if k not in ("name", "type", "input", "description"):
+                    if k == "mask":
+                        v = cast(int, v)
+                        v = hex(v)  # noqa: PLW2901
+                    proxy_kwargs += f"{k}={v},"
+            if proxy_kwargs:
+                proxy_kwargs = proxy_kwargs[:-1]  # remove the last comma
+
+            if proxy_description:
+                field_docs.append(
+                    PROXY_DESCRIPTION.format(
+                        name=proxy_name,
+                        description=proxy_description,
+                        target=proxy_target,
+                        input=proxy_input,
+                    )
+                )
+
+            fields.append(
+                PROXY_FIELD.format(
+                    name=proxy_name,
+                    input=proxy_input,
+                    target=proxy_target,
+                    type=proxy_type,
+                    kwargs=proxy_kwargs,
+                )
+            )
+
+    # Split lines inside docstrings
+
+    if base in main_doc_repo:
+        field_docs += ["", f"Inherited from :class:`{base}`:", ""] + [
+            line.strip("\n\r\t").replace(" " * 4, "", 1) for line in main_doc_repo[base].split("\n")
+        ]
+    else:
+        print(f"Warning: {base} not found in main_doc_repo")  # noqa: T201
+
+    if field_docs[0] == "":
+        field_docs = field_docs[1:]
+    field_docs_str = "\n    ".join("\n".join(field_docs).split("\n"))
+    main_doc_repo[name] = field_docs_str
+    return (
+        BASE_CLASS.format(
+            name=name,
+            base=base,
+            class_description=entity_description["description"],
+            fields_docstring=field_docs_str,
+            fields="\n    ".join(fields),
+        ),
+        used_enums,
+        used_types,
+    )
+
+
+def write_files(entity_data: list[EntityData]) -> None:
+    """Generate the base file for the entities.
+
+    :param entity_data: The entity data to generate the base file from.
+
+    :return: The generated string for the base file.
+    """
+    types: set[str] = set()
+    enums: set[str] = set()
+    all_classes: list[str] = []
+    class_code: list[str] = []
+    generated: list[str] = []
+    for entity in entity_data:
+        class_str, used_enums, used_types = generate_class(entity)
+        entity_name = cast(str, entity["name"]) + NAME_SUFFIX
+        types.update(used_types)
+        enums.update(used_enums)
+        all_classes.append(entity_name)
+        class_code.append(class_str)
+        generated.append(entity_name)
+    all_classes_str = ",\n    ".join(f'"{c}"' for c in all_classes + list(enums))
+    types_str = ", ".join(types)
+    enums_str = ", ".join(enums)
+    generated_str = ", ".join(generated)
+
+    header = FILE_HEADER.format(
+        enums=enums_str,
+        all=all_classes_str,
+    )
+    with Path(FILE_PATH).open("w") as file:
+        file.write(
+            BASE_FILE.format(
+                types=types_str,
+                header=header,
+                classes="\n\n".join(class_code),
+            )
+        )
+
+    with Path(INIT_PATH).open("w") as file:
+        file.write(INIT_FILE.format(header=header, generated=generated_str))
+
+
+def format_ruff(path: Path) -> None:
+    """Format the generated files with ruff.
+
+    :param path: The path to the file to format.
+    """
+    # Get the python site packages path
+    subprocess.run(
+        [sys.executable, "-m", "ruff", "format", str(path.absolute())],  # noqa: S603
+        check=True,
+    )
+
+
+if __name__ == "__main__":
+    write_files(ENTITY_DATA)
+    format_ruff(Path(FILE_PATH))
+    format_ruff(Path(INIT_PATH))

mcproto/types/entity/metadata.py

@@ -302,6 +302,7 @@ def test_serialization(self, kwargs: dict[str, Any], expected_bytes: bytes):
         def test_deserialization(self, kwargs: dict[str, Any], expected_bytes: bytes):
             """Test deserialization of the object."""
             buf = Buffer(expected_bytes)
+
             obj = cls.deserialize(buf)
             equality = cls(**kwargs) == obj
             error_message: list[str] = []

mcproto/types/entity/metadata_types.py

@@ -0,0 +1 @@
+from __future__ import annotations

scripts/__init__.py

@@ -0,0 +1,90 @@
+from mcproto.types.entity import PandaEM
+from mcproto.buffer import Buffer
+
+
+import pytest
+from mcproto.types.entity.metadata import proxy, entry, EntityMetadataCreator, EntityMetadata
+from mcproto.types.entity.metadata_types import ByteEME, Masked
+
+
+def test_panda():
+    """Test the Panda entity (it has a lot of inherited fields, so it's a good test case)."""
+    panda = PandaEM()
+
+    assert panda.serialize() == b"\xff"  # No metadata
+
+    panda.active_hand = 0
+    panda.is_hand_active = True
+    panda.is_riptide_spin_attack = True
+    # Index 8, Type 0 (byte), Value 0b00000101
+    assert panda.serialize() == b"\x08\x00\x05\xff"
+    # 0bxx1 hand active
+    # 0bx0x main hand active (1 for offhand)
+    # 0b1xx riptide spin attack
+
+    panda.is_sneezing = True
+    # Index 8, Type 0 (byte), Value 0b00000101, Index 22, Type 0 (byte), Value 2
+    assert panda.serialize() == b"\x08\x00\x05\x16\x00\x02\xff"
+
+    panda.active_hand = 0
+    panda.is_hand_active = False
+    panda.is_riptide_spin_attack = False
+    panda.eat_timer = -1  # VarInt 0xff 0xff 0xff 0xff 0x0f
+    # Index 22, Type 0 (byte), Value 2, Index 19, Type 1 (VarInt), Value -1
+    assert panda.serialize() == b"\x13\x01\xff\xff\xff\xff\x0f\x16\x00\x02\xff"
+
+    buf = Buffer(b"\x13\x01\x02\x16\x00\x02\x08\x00\x07\xff")
+    panda2 = PandaEM.deserialize(buf)
+    assert panda2.active_hand == 1
+    assert panda2.is_hand_active
+    assert panda2.is_riptide_spin_attack
+    assert panda2.eat_timer == 2
+    assert panda2.is_sneezing
+    assert not panda2.is_sitting
+
+
+def test_kwargs():
+    """Test kwargs for EnitityMetadata."""
+    panda = PandaEM(custom_name="test", is_custom_name_visible=True)
+    assert panda.custom_name == "test"
+    assert panda.is_custom_name_visible
+
+
+def test_class_error():
+    """Test errors for EntityMetadataCreator."""
+    with pytest.raises(TypeError):
+        proxy("test", Masked, mask=0x1)  # wrong type
+
+    with pytest.raises(TypeError):
+        proxy(object, Masked, mask=0x1)  # wrong type
+
+    with pytest.raises(ValueError):
+
+        class Test(metaclass=EntityMetadataCreator):  # type: ignore
+            test: int
+
+    with pytest.raises(ValueError):
+
+        class Test(metaclass=EntityMetadataCreator):  # type: ignore # noqa: F811
+            test: int = 0
+
+    with pytest.raises(ValueError):
+        EntityMetadata(1, 1)  # type: ignore
+
+    with pytest.raises(ValueError):
+
+        class Test(metaclass=EntityMetadataCreator):  # noqa: F811
+            test: int = proxy(entry(ByteEME, 1), Masked, mask=0x1)
+
+    buf = Buffer(b"\x00\x02\x00")  # Wrong metadata type
+    with pytest.raises(TypeError):
+        ByteEME.deserialize(buf)
+
+    EntityMetadata()
+
+    buf = Buffer(b"\x00\xff\x00")  # Invalid metadata type
+    with pytest.raises(TypeError):
+        EntityMetadata.deserialize(buf)
+
+    with pytest.raises(ValueError):
+        EntityMetadata(keyword="test")