path: root/azalea-entity/src/data.rs

//! Define some types needed for entity metadata.

use std::io::{self, Cursor, Write};

use azalea_auth::game_profile::{GameProfile, GameProfileProperties};
use azalea_buf::{AzBuf, AzaleaRead, AzaleaReadVar, AzaleaWrite, AzaleaWriteVar, BufReadError};
use azalea_chat::FormattedText;
use azalea_core::{
    direction::Direction,
    position::{BlockPos, GlobalPos, Vec3f32},
    resource_location::ResourceLocation,
};
use azalea_inventory::ItemStack;
use bevy_ecs::component::Component;
use derive_more::Deref;
use enum_as_inner::EnumAsInner;
use uuid::Uuid;

use crate::particle::Particle;

#[derive(Clone, Debug, Deref, PartialEq)]
pub struct EntityMetadataItems(pub Vec<EntityDataItem>);

#[derive(Clone, Debug, PartialEq)]
pub struct EntityDataItem {
    // we can't identify what the index is for here because we don't know the
    // entity type
    pub index: u8,
    pub value: EntityDataValue,
}

impl AzaleaRead for EntityMetadataItems {
    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
        let mut metadata = Vec::new();
        loop {
            let id = u8::azalea_read(buf)?;
            if id == 0xff {
                break;
            }
            let value = EntityDataValue::azalea_read(buf)?;
            metadata.push(EntityDataItem { index: id, value });
        }
        Ok(EntityMetadataItems(metadata))
    }
}

impl AzaleaWrite for EntityMetadataItems {
    fn azalea_write(&self, buf: &mut impl Write) -> io::Result<()> {
        for item in &self.0 {
            item.index.azalea_write(buf)?;
            item.value.azalea_write(buf)?;
        }
        0xffu8.azalea_write(buf)?;
        Ok(())
    }
}

// Note: This enum is partially generated and parsed by
// codegen/lib/code/entity.py
#[derive(Clone, Debug, EnumAsInner, AzBuf, PartialEq)]
pub enum EntityDataValue {
    Byte(u8),
    Int(#[var] i32),
    Long(#[var] i64),
    Float(f32),
    String(String),
    FormattedText(FormattedText),
    OptionalFormattedText(Option<FormattedText>),
    ItemStack(ItemStack),
    Boolean(bool),
    Rotations(Rotations),
    BlockPos(BlockPos),
    OptionalBlockPos(Option<BlockPos>),
    Direction(Direction),
    OptionalLivingEntityReference(Option<Uuid>),
    BlockState(azalea_block::BlockState),
    /// If this is air, that means it's absent,
    OptionalBlockState(azalea_block::BlockState),
    Particle(Particle),
    Particles(Vec<Particle>),
    VillagerData(VillagerData),
    // 0 for absent; 1 + actual value otherwise. Used for entity IDs.
    OptionalUnsignedInt(OptionalUnsignedInt),
    Pose(Pose),
    CatVariant(azalea_registry::CatVariant),
    ChickenVariant(azalea_registry::ChickenVariant),
    CowVariant(azalea_registry::CowVariant),
    WolfVariant(azalea_registry::WolfVariant),
    WolfSoundVariant(azalea_registry::WolfSoundVariant),
    FrogVariant(azalea_registry::FrogVariant),
    PigVariant(azalea_registry::PigVariant),
    OptionalGlobalPos(Option<GlobalPos>),
    PaintingVariant(azalea_registry::PaintingVariant),
    SnifferState(SnifferStateKind),
    ArmadilloState(ArmadilloStateKind),
    CopperGolemState(CopperGolemStateKind),
    WeatheringCopperState(WeatheringCopperStateKind),
    Vector3(Vec3f32),
    Quaternion(Quaternion),
    ResolvableProfile(ResolvableProfile),
}

#[derive(Clone, Debug, PartialEq)]
pub struct OptionalUnsignedInt(pub Option<u32>);

#[derive(Clone, Debug, AzBuf, PartialEq)]
pub struct Quaternion {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

#[derive(Clone, Debug, AzBuf, Default, PartialEq)]
pub struct ResolvableProfile {
    pub unpack: Box<PartialOrFullProfile>,
    pub skin_patch: Box<PlayerSkinPatch>,
}

#[derive(Clone, Debug, AzBuf, PartialEq)]
pub enum PartialOrFullProfile {
    Partial(PartialProfile),
    Full(GameProfile),
}
impl Default for PartialOrFullProfile {
    fn default() -> Self {
        Self::Partial(PartialProfile::default())
    }
}

#[derive(Clone, Debug, AzBuf, Default, PartialEq)]
pub struct PartialProfile {
    #[limit(16)]
    pub name: Option<String>,
    pub id: Option<Uuid>,
    pub properties: GameProfileProperties,
}

#[derive(Clone, Debug, AzBuf, Default, PartialEq)]
pub struct PlayerSkinPatch {
    pub body: Option<ResourceTexture>,
    pub cape: Option<ResourceTexture>,
    pub elytra: Option<ResourceTexture>,
    pub model: Option<PlayerModelType>,
}

#[derive(Clone, Debug, Copy, AzBuf, Default, PartialEq)]
pub enum PlayerModelType {
    #[default]
    Wide,
    Slim,
}

#[derive(Clone, Debug, AzBuf, PartialEq)]
pub struct ResourceTexture {
    pub id: ResourceLocation,
}

// mojang just calls this ArmadilloState but i added "Kind" since otherwise it
// collides with a name in metadata.rs
#[derive(Clone, Debug, Copy, Default, AzBuf, PartialEq)]
pub enum ArmadilloStateKind {
    #[default]
    Idle,
    Rolling,
    Scared,
}

impl AzaleaRead for OptionalUnsignedInt {
    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
        let val = u32::azalea_read_var(buf)?;
        Ok(OptionalUnsignedInt(if val == 0 {
            None
        } else {
            Some(val - 1)
        }))
    }
}
impl AzaleaWrite for OptionalUnsignedInt {
    fn azalea_write(&self, buf: &mut impl Write) -> io::Result<()> {
        match self.0 {
            Some(val) => (val + 1).azalea_write_var(buf),
            None => 0u32.azalea_write_var(buf),
        }
    }
}

/// A set of x, y, and z rotations. This is used for armor stands.
#[derive(Clone, Debug, AzBuf, Default, PartialEq)]
pub struct Rotations {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

#[derive(Clone, Debug, Copy, AzBuf, Default, Component, Eq, PartialEq)]
pub enum Pose {
    #[default]
    Standing = 0,
    FallFlying,
    Sleeping,
    Swimming,
    SpinAttack,
    Crouching,
    LongJumping,
    Dying,
    Croaking,
    UsingTongue,
    Sitting,
    Roaring,
    Sniffing,
    Emerging,
    Digging,
    Sliding,
    Shooting,
    Inhaling,
}

#[derive(Debug, Clone, AzBuf, PartialEq)]
pub struct VillagerData {
    pub kind: azalea_registry::VillagerKind,
    pub profession: azalea_registry::VillagerProfession,
    #[var]
    pub level: u32,
}

#[derive(Debug, Copy, Clone, AzBuf, Default, PartialEq)]
pub enum SnifferStateKind {
    #[default]
    Idling,
    FeelingHappy,
    Scenting,
    Sniffing,
    Searching,
    Digging,
    Rising,
}

#[derive(Debug, Copy, Clone, AzBuf, Default, PartialEq)]
pub enum CopperGolemStateKind {
    #[default]
    Idle,
    GettingItem,
    GettingNoItem,
    DroppingItem,
    DroppingNoItem,
}
#[derive(Debug, Copy, Clone, AzBuf, Default, PartialEq)]
pub enum WeatheringCopperStateKind {
    #[default]
    Unaffected,
    Exposed,
    Weathered,
    Oxidized,
}