Physics (#11)

* Put physics module in azalea-entity

* port aabb

* add more stuff to PositionXYZ

* azalea-physics

* important collision things

* more physics stuff

* backup because i'm about to delete shapes

* more shape stuff

* CubeVoxelShape

* no compile errors???

insane

* impl VoxelShape for ArrayVoxelShape

* Shapes stuff

* collide_x but it doesn't work yet

* binary_search

* it compiles

* Entity has bounding box

* Update discrete_voxel_shape.rs

* Entity::make_bounding_box

* ok i'm about to merge az-entity and az-world

might be a terrible idea which is why i'm committing first

* ok so i moved entity to world

* on_pos and move_entity compiles

* add send_position

* move collision stuff to collision module in az-physics

* dimension is no longer an Option

* start trying to do collision for the client

* collision works :tada:

* start adding palette resizing

* get_and_set (pain)

* it compiles but probably won't work

* add a test

* remove printlns

* add more tests for palette stuff

* ClientboundMoveVec3Packet -> ClientboundMoveEntityPosPacket

i think i changed this on accident once

* palette resizing works

todo: remove the printlns

* Remove printlns in palette.rs

* fix issues from merge

* fixes + work a bit more on physics

* Better entities (#19)

* well it compiles

* add tests to entity storage

* add suggestions in azalea-brigadier

* this probably causes ub

* fix brigadiersuggestions

* get rid of entityid

* test From<EntityMut> for EntityRef

* don't mention other libraries since there's too many

* fix warnings

* do todos in brigadier suggestions

* work on physics

* more physics stuff

* remove trait feature on az-block

i think rust gets confused and compiles the macro without the feature

* bump ahash

* aes tests in az-crypto

* optimize aes's deps

* fix crashes

* fix section_index for negative numbers and test

* fix BlockPos protocol implementation

* remove some debug prints

* prepare to add ai_step

* make ai step work

* clippy

1 files changed, 148 insertions, 0 deletions

diff --git a/azalea-world/src/entity/data.rs b/azalea-world/src/entity/data.rs
new file mode 100644
index 00000000..ff708653
--- /dev/null
+++ b/azalea-world/src/entity/data.rs
@@ -0,0 +1,148 @@
+use azalea_buf::{BufReadError, McBufVarReadable};
+use azalea_buf::{McBuf, McBufReadable, McBufWritable};
+use azalea_chat::component::Component;
+use azalea_core::{BlockPos, Direction, Particle, Slot};
+use std::io::{Read, Write};
+use uuid::Uuid;
+
+#[derive(Clone, Debug)]
+pub struct EntityMetadata(Vec<EntityDataItem>);
+
+#[derive(Clone, Debug)]
+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 McBufReadable for EntityMetadata {
+    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+        let mut metadata = Vec::new();
+        loop {
+            let index = u8::read_from(buf)?;
+            if index == 0xff {
+                break;
+            }
+            let value = EntityDataValue::read_from(buf)?;
+            metadata.push(EntityDataItem { index, value });
+        }
+        Ok(EntityMetadata(metadata))
+    }
+}
+
+impl McBufWritable for EntityMetadata {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        for item in &self.0 {
+            item.index.write_into(buf)?;
+            item.value.write_into(buf)?;
+        }
+        0xffu8.write_into(buf)?;
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum EntityDataValue {
+    Byte(u8),
+    // varint
+    Int(i32),
+    Float(f32),
+    String(String),
+    Component(Component),
+    OptionalComponent(Option<Component>),
+    ItemStack(Slot),
+    Boolean(bool),
+    Rotations { x: f32, y: f32, z: f32 },
+    BlockPos(BlockPos),
+    OptionalBlockPos(Option<BlockPos>),
+    Direction(Direction),
+    OptionalUuid(Option<Uuid>),
+    // 0 for absent (implies air); otherwise, a block state ID as per the global palette
+    // this is a varint
+    OptionalBlockState(Option<i32>),
+    CompoundTag(azalea_nbt::Tag),
+    Particle(Particle),
+    VillagerData(VillagerData),
+    // 0 for absent; 1 + actual value otherwise. Used for entity IDs.
+    OptionalUnsignedInt(Option<u32>),
+    Pose(Pose),
+}
+
+impl McBufReadable for EntityDataValue {
+    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+        let data_type = u32::var_read_from(buf)?;
+        Ok(match data_type {
+            0 => EntityDataValue::Byte(u8::read_from(buf)?),
+            1 => EntityDataValue::Int(i32::var_read_from(buf)?),
+            2 => EntityDataValue::Float(f32::read_from(buf)?),
+            3 => EntityDataValue::String(String::read_from(buf)?),
+            4 => EntityDataValue::Component(Component::read_from(buf)?),
+            5 => EntityDataValue::OptionalComponent(Option::<Component>::read_from(buf)?),
+            6 => EntityDataValue::ItemStack(Slot::read_from(buf)?),
+            7 => EntityDataValue::Boolean(bool::read_from(buf)?),
+            8 => EntityDataValue::Rotations {
+                x: f32::read_from(buf)?,
+                y: f32::read_from(buf)?,
+                z: f32::read_from(buf)?,
+            },
+            9 => EntityDataValue::BlockPos(BlockPos::read_from(buf)?),
+            10 => EntityDataValue::OptionalBlockPos(Option::<BlockPos>::read_from(buf)?),
+            11 => EntityDataValue::Direction(Direction::read_from(buf)?),
+            12 => EntityDataValue::OptionalUuid(Option::<Uuid>::read_from(buf)?),
+            13 => EntityDataValue::OptionalBlockState({
+                let val = i32::read_from(buf)?;
+                if val == 0 {
+                    None
+                } else {
+                    Some(val)
+                }
+            }),
+            14 => EntityDataValue::CompoundTag(azalea_nbt::Tag::read_from(buf)?),
+            15 => EntityDataValue::Particle(Particle::read_from(buf)?),
+            16 => EntityDataValue::VillagerData(VillagerData::read_from(buf)?),
+            17 => EntityDataValue::OptionalUnsignedInt({
+                let val = u32::var_read_from(buf)?;
+                if val == 0 {
+                    None
+                } else {
+                    Some((val - 1) as u32)
+                }
+            }),
+            18 => EntityDataValue::Pose(Pose::read_from(buf)?),
+            _ => {
+                return Err(BufReadError::UnexpectedEnumVariant {
+                    id: data_type as i32,
+                })
+            }
+        })
+    }
+}
+
+impl McBufWritable for EntityDataValue {
+    fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
+        todo!();
+    }
+}
+
+#[derive(Clone, Debug, Copy, McBuf)]
+pub enum Pose {
+    Standing = 0,
+    FallFlying = 1,
+    Sleeping = 2,
+    Swimming = 3,
+    SpinAttack = 4,
+    Sneaking = 5,
+    LongJumping = 6,
+    Dying = 7,
+}
+
+#[derive(Debug, Clone, McBuf)]
+pub struct VillagerData {
+    #[var]
+    type_: u32,
+    #[var]
+    profession: u32,
+    #[var]
+    level: u32,
+}