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, 115 insertions, 0 deletions

diff --git a/azalea-core/src/cursor3d.rs b/azalea-core/src/cursor3d.rs
new file mode 100644
index 00000000..fa265c8a
--- /dev/null
+++ b/azalea-core/src/cursor3d.rs
@@ -0,0 +1,115 @@
+use crate::BlockPos;
+
+pub struct Cursor3d {
+    index: usize,
+
+    origin_x: i32,
+    origin_y: i32,
+    origin_z: i32,
+
+    width: usize,
+    height: usize,
+    depth: usize,
+
+    end: usize,
+}
+
+impl Iterator for Cursor3d {
+    type Item = CursorIteration;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index == self.end {
+            return None;
+        }
+        let x = self.index % self.width;
+        let r = self.index / self.width;
+        let y = r % self.height;
+        let z = r / self.height;
+        self.index += 1;
+
+        let mut iteration_type = 0;
+        if x == 0 || x == self.width - 1 {
+            iteration_type += 1;
+        }
+        if y == 0 || y == self.height - 1 {
+            iteration_type += 1;
+        }
+        if z == 0 || z == self.depth - 1 {
+            iteration_type += 1;
+        }
+
+        Some(CursorIteration {
+            pos: BlockPos {
+                x: self.origin_x + x as i32,
+                y: self.origin_y + y as i32,
+                z: self.origin_z + z as i32,
+            },
+            iteration_type: iteration_type.into(),
+        })
+    }
+}
+
+#[repr(u8)]
+#[derive(Eq, PartialEq, Debug)]
+pub enum CursorIterationType {
+    Inside = 0,
+    Face = 1,
+    Edge = 2,
+    Corner = 3,
+}
+
+pub struct CursorIteration {
+    pub pos: BlockPos,
+    pub iteration_type: CursorIterationType,
+}
+
+impl Cursor3d {
+    pub fn new(
+        origin_x: i32,
+        origin_y: i32,
+        origin_z: i32,
+        end_x: i32,
+        end_y: i32,
+        end_z: i32,
+    ) -> Self {
+        println!(
+            "making cursor3d with origin: {}, {}, {} and end: {}, {}, {}",
+            origin_x, origin_y, origin_z, end_x, end_y, end_z
+        );
+        let width = (end_x - origin_x + 1)
+            .try_into()
+            .expect("Impossible width.");
+        let height = (end_y - origin_y + 1)
+            .try_into()
+            .expect("Impossible height.");
+        let depth = (end_z - origin_z + 1)
+            .try_into()
+            .expect("Impossible depth.");
+
+        Self {
+            index: 0,
+
+            origin_x,
+            origin_y,
+            origin_z,
+
+            width,
+            height,
+            depth,
+
+            end: width * height * depth,
+        }
+    }
+}
+
+impl From<u8> for CursorIterationType {
+    fn from(value: u8) -> Self {
+        match value {
+            0 => CursorIterationType::Inside,
+            1 => CursorIterationType::Face,
+            2 => CursorIterationType::Edge,
+            3 => CursorIterationType::Corner,
+            _ => panic!("Invalid iteration type"),
+        }
+    }
+}