diff --git a/azalea-core/src/lib.rs b/azalea-core/src/lib.rs
index 5aca7d52..66d9a2ea 100755
--- a/azalea-core/src/lib.rs
+++ b/azalea-core/src/lib.rs
@@ -49,7 +49,7 @@ pub fn floor_mod(x: i32, y: u32) -> u32 {
 }
 
 // TODO: make this generic
-pub fn binary_search(mut min: u32, max: u32, predicate: &dyn Fn(u32) -> bool) -> u32 {
+pub fn binary_search(mut min: i32, max: i32, predicate: &dyn Fn(i32) -> bool) -> i32 {
     let mut diff = max - min;
     while diff > 0 {
         let diff_mid = diff / 2;
diff --git a/azalea-physics/src/collision/dimension_collisions.rs b/azalea-physics/src/collision/dimension_collisions.rs
index 59514fda..5f9fa039 100644
--- a/azalea-physics/src/collision/dimension_collisions.rs
+++ b/azalea-physics/src/collision/dimension_collisions.rs
@@ -91,7 +91,6 @@ impl<'a> Iterator for BlockCollisions<'a> {
             let chunk_lock = chunk.lock().unwrap();
 
             let pos = item.pos;
-            println!("getting block at {:?}", pos);
             let block_state: BlockState = chunk_lock.get(&(&pos).into(), self.dimension.min_y());
             // let block: Box<dyn Block> = block_state.into();
 
diff --git a/azalea-physics/src/collision/shape.rs b/azalea-physics/src/collision/shape.rs
index 45822d07..c8428a08 100644
--- a/azalea-physics/src/collision/shape.rs
+++ b/azalea-physics/src/collision/shape.rs
@@ -66,10 +66,17 @@ pub trait VoxelShape {
         self.get_coords(axis)[index]
     }
 
-    fn find_index(&self, axis: Axis, coord: f64) -> u32 {
-        binary_search(0, self.shape().size(axis) + 1, &|t| {
+    fn find_index(&self, axis: Axis, coord: f64) -> i32 {
+        let r = binary_search(0, (self.shape().size(axis) + 1) as i32, &|t| {
+            println!(
+                "checking {} ({}) against {}",
+                t,
+                self.get(axis, t as usize),
+                coord
+            );
             coord < self.get(axis, t as usize)
-        }) - 1
+        }) - 1;
+        r
     }
 
     fn collide(&self, axis: &Axis, entity_box: &AABB, movement: f64) -> f64 {
@@ -90,19 +97,19 @@ pub trait VoxelShape {
         let y_axis = inverse_axis_cycle.cycle(Axis::Y);
         let z_axis = inverse_axis_cycle.cycle(Axis::Z);
 
-        // i gave up on names at this point (these are the obfuscated names from fernflower)
-        let var9 = entity_box.max(&x_axis);
-        let var11 = entity_box.min(&x_axis);
+        let max_x = entity_box.max(&x_axis);
+        let min_x = entity_box.min(&x_axis);
 
-        let var13 = self.find_index(x_axis, var11 + EPSILON);
-        let var14 = self.find_index(x_axis, var9 - EPSILON);
+        // i gave up on names at this point (these are the obfuscated names from fernflower)
+        let var13 = self.find_index(x_axis, min_x + EPSILON);
+        let var14 = self.find_index(x_axis, max_x - EPSILON);
 
         let var15 = cmp::max(
             0,
             self.find_index(y_axis, entity_box.min(&y_axis) + EPSILON),
         );
         let var16 = cmp::min(
-            self.shape().size(y_axis),
+            self.shape().size(y_axis) as i32,
             self.find_index(y_axis, entity_box.max(&y_axis) - EPSILON) + 1,
         );
 
@@ -111,23 +118,23 @@ pub trait VoxelShape {
             self.find_index(z_axis, entity_box.min(&z_axis) + EPSILON),
         );
         let var18 = cmp::min(
-            self.shape().size(z_axis),
+            self.shape().size(z_axis) as i32,
             self.find_index(z_axis, entity_box.max(&z_axis) - EPSILON) + 1,
         );
 
         let var19 = self.shape().size(x_axis);
-
+        println!("movement: {}", movement);
         if movement > 0. {
-            for var20 in var14 + 1..var19 {
+            for var20 in var14 + 1..(var19 as i32) {
                 for var21 in var15..var16 {
                     for var22 in var17..var18 {
                         if self.shape().is_full_wide_axis_cycle(
                             inverse_axis_cycle,
-                            var20,
-                            var21,
-                            var22,
+                            var20.try_into().unwrap(),
+                            var21.try_into().unwrap(),
+                            var22.try_into().unwrap(),
                         ) {
-                            let var23 = self.get(x_axis, var20 as usize) - var9;
+                            let var23 = self.get(x_axis, var20 as usize) - max_x;
                             if var23 >= -EPSILON {
                                 movement = f64::min(movement, var23);
                             }
@@ -137,20 +144,23 @@ pub trait VoxelShape {
                 }
             }
         } else if movement < 0. {
-            for var20 in (var13 - 1)..=0 {
-                for var21 in var15..var16 {
-                    for var22 in var17..var18 {
-                        if self.shape().is_full_wide_axis_cycle(
-                            inverse_axis_cycle,
-                            var20,
-                            var21,
-                            var22,
-                        ) {
-                            let var23 = self.get(x_axis, (var20 + 1) as usize) - var11;
-                            if var23 <= EPSILON {
-                                movement = f64::max(movement, var23);
+            println!("hmmm var13={}", var13);
+            if var13 > 0 {
+                for var20 in (var13 - 1)..=0 {
+                    for var21 in var15..var16 {
+                        for var22 in var17..var18 {
+                            if self.shape().is_full_wide_axis_cycle(
+                                inverse_axis_cycle,
+                                var20.try_into().unwrap(),
+                                var21.try_into().unwrap(),
+                                var22.try_into().unwrap(),
+                            ) {
+                                let var23 = self.get(x_axis, (var20 + 1) as usize) - min_x;
+                                if var23 <= EPSILON {
+                                    movement = f64::max(movement, var23);
+                                }
+                                return movement;
                             }
-                            return movement;
                         }
                     }
                 }
@@ -234,6 +244,11 @@ impl VoxelShape for CubeVoxelShape {
         }
         parts
     }
+
+    fn find_index(&self, axis: Axis, coord: f64) -> i32 {
+        let n = self.shape().size(axis);
+        (f64::clamp(coord * (n as f64), -1f64, n as f64)) as i32
+    }
 }
 
 #[cfg(test)]
diff --git a/azalea-physics/src/lib.rs b/azalea-physics/src/lib.rs
index 7202a3b8..8f9c256e 100644
--- a/azalea-physics/src/lib.rs
+++ b/azalea-physics/src/lib.rs
@@ -191,7 +191,7 @@ mod tests {
             ),
         );
         let old_block_state =
-            dim.set_block_state(&BlockPos { x: 0, y: 70, z: 0 }, BlockState::Stone);
+            dim.set_block_state(&BlockPos { x: 0, y: 69, z: 0 }, BlockState::Stone);
         assert!(
             old_block_state.is_some(),
             "Old block state should exist, if this fails that means the chunk wasn't loaded and the block didn't get placed"