Add mining to the pathfinder (#122)

* basic pathfinder mining poc

* mining descending and autotool

* pathfinder mining descending

* pathfinder fixes

* allow disabling pathfinder miner and other fixes

* small optimization to avoid chunk vec iter lookup sometimes

* seeded rng in pathfinder bench

* consistently use f32::INFINITY

this brings performance much closer to how it was before

* astar heuristic optimization from baritone

* add downward_move

* fix downward move execute

* avoid liquids and falling blocks when mining

* fix COST_HEURISTIC

* fix to not path through flowing liquids

* only reset pathfinder timeout while mining if the block is close enough

* cache mining costs of block positions

* fix mine_while_at_start and move PathfinderDebugParticles to its own module

* add ReachBlockPosGoal

in other news: azalea's sin/cos functions were broken this whole time and i never noticed

* clippy and add things that i accidentally didn't commit

* improve wording on doc for azalea::pathfinder

1 files changed, 45 insertions, 0 deletions

diff --git a/azalea-core/src/position.rs b/azalea-core/src/position.rs
index 4cdf3f18..e9864035 100755
--- a/azalea-core/src/position.rs
+++ b/azalea-core/src/position.rs
@@ -5,6 +5,7 @@
 
 use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufWritable};
 use std::{
+    fmt,
     hash::Hash,
     io::{Cursor, Write},
     ops::{Add, AddAssign, Mul, Rem, Sub},
@@ -65,6 +66,43 @@ macro_rules! vec3_impl {
                 }
             }
 
+            /// Return a new instance of this position with the z coordinate subtracted
+            /// by the given number.
+            pub fn north(&self, z: $type) -> Self {
+                Self {
+                    x: self.x,
+                    y: self.y,
+                    z: self.z - z,
+                }
+            }
+            /// Return a new instance of this position with the x coordinate increased
+            /// by the given number.
+            pub fn east(&self, x: $type) -> Self {
+                Self {
+                    x: self.x + x,
+                    y: self.y,
+                    z: self.z,
+                }
+            }
+            /// Return a new instance of this position with the z coordinate increased
+            /// by the given number.
+            pub fn south(&self, z: $type) -> Self {
+                Self {
+                    x: self.x,
+                    y: self.y,
+                    z: self.z + z,
+                }
+            }
+            /// Return a new instance of this position with the x coordinate subtracted
+            /// by the given number.
+            pub fn west(&self, x: $type) -> Self {
+                Self {
+                    x: self.x - x,
+                    y: self.y,
+                    z: self.z,
+                }
+            }
+
             #[inline]
             pub fn dot(&self, other: Self) -> $type {
                 self.x * other.x + self.y * other.y + self.z * other.z
@@ -501,6 +539,13 @@ impl From<Vec3> for ChunkBlockPos {
     }
 }
 
+impl fmt::Display for BlockPos {
+    /// Display a block position as `x y z`.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} {} {}", self.x, self.y, self.z)
+    }
+}
+
 const PACKED_X_LENGTH: u64 = 1 + 25; // minecraft does something a bit more complicated to get this 25
 const PACKED_Z_LENGTH: u64 = PACKED_X_LENGTH;
 const PACKED_Y_LENGTH: u64 = 64 - PACKED_X_LENGTH - PACKED_Z_LENGTH;