fix: clippy warnings

.github/workflows/ci.yml

@@ -9,76 +9,30 @@ env:
   RUSTFLAGS: --deny warnings
   RUSTDOCFLAGS: --deny warnings
 jobs:
-  # Run tests.
+  build-and-test:
-  test:
-    name: Tests
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     steps:
-      - name: Checkout repository
+      - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
-      - name: Install Rust toolchain
+      - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
-      - name: Install dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Populate target directory from cache
-        uses: Leafwing-Studios/cargo-cache@v2
         with:
-          sweep-cache: true
+          toolchain: stable
-      - name: Run tests
+          components: clippy, rustfmt
+      - name: Run sccache-cache
+        uses: mozilla-actions/sccache-action@v0.0.9
+      - name: Install cargo-nextest
+        uses: taiki-e/install-action@cargo-nextest
+      - name: Run Clippy
+        run: cargo clippy --locked --workspace --all-targets --all-features -- -D warnings
+      - name: Run formatting
+        run: cargo fmt --all --check
+      - name: Run Tests
         run: |
-          cargo test --locked --workspace --all-features --all-targets
+          cargo nextest run --all-features --all-targets
-          # Workaround for https://github.com/rust-lang/cargo/issues/6669
           cargo test --locked --workspace --all-features --doc
-  # Run clippy lints.
+      - name: Check Documentation
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-      - name: Install dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Populate target directory from cache
-        uses: Leafwing-Studios/cargo-cache@v2
-        with:
-          sweep-cache: true
-      - name: Run clippy lints
-        run: cargo clippy --locked --workspace --all-features -- --deny warnings
-  # Check formatting.
-  format:
-    name: Format
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
-      - name: Run cargo fmt
-        run: cargo fmt --all -- --check
-  # Check documentation.
-  doc:
-    name: Docs
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Populate target directory from cache
-        uses: Leafwing-Studios/cargo-cache@v2
-        with:
-          sweep-cache: true
-      - name: Check documentation
         run: cargo doc --locked --workspace --all-features --document-private-items --no-deps

Cargo.lock

@@ -1248,7 +1248,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
  "syn",
 ]
@@ -1631,7 +1631,7 @@ dependencies = [
  "log",
  "rangemap",
  "rayon",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "rustybuzz",
  "self_cell",
  "swash",
@@ -1743,6 +1743,18 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
 
+[[package]]
+name = "deprecate-until"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a3767f826efbbe5a5ae093920b58b43b01734202be697e1354914e862e8e704"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "semver",
+ "syn",
+]
+
 [[package]]
 name = "derive_more"
 version = "1.0.0"
@@ -2014,21 +2026,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
 
-[[package]]
-name = "futures"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -2036,7 +2033,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
- "futures-sink",
 ]
 
 [[package]]
@@ -2045,17 +2041,6 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
-[[package]]
-name = "futures-executor"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
-
 [[package]]
 name = "futures-io"
 version = "0.3.31"
@@ -2086,12 +2071,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "futures-sink"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
-
 [[package]]
 name = "futures-task"
 version = "0.3.31"
@@ -2110,13 +2089,9 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
- "futures-channel",
  "futures-core",
- "futures-io",
  "futures-macro",
- "futures-sink",
  "futures-task",
- "memchr",
  "pin-project-lite",
  "pin-utils",
  "slab",
@@ -2375,7 +2350,7 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
 name = "hexlab"
-version = "0.5.0"
+version = "0.6.1"
 dependencies = [
  "bevy",
  "bevy_reflect",
@@ -2383,6 +2358,7 @@ dependencies = [
  "claims",
  "glam",
  "hexx",
+ "pathfinding",
  "rand",
  "rstest",
  "serde",
@@ -2391,9 +2367,9 @@ dependencies = [
 
 [[package]]
 name = "hexx"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34b47b6f7ee46bba869534a92306b7e7f549bec38114a4ba0288b9321617db22"
+checksum = "4b450e02a24a4a981c895be4cd2752e2401996c545971309730c4e812b984691"
 dependencies = [
  "bevy_reflect",
  "glam",
@@ -2457,6 +2433,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "integer-sqrt"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "276ec31bcb4a9ee45f58bec6f9ec700ae4cf4f4f8f2fa7e06cb406bd5ffdd770"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "io-kit-sys"
 version = "0.4.1"
@@ -2724,7 +2709,7 @@ dependencies = [
  "indexmap",
  "log",
  "pp-rs",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "spirv",
  "termcolor",
  "thiserror 1.0.69",
@@ -2745,7 +2730,7 @@ dependencies = [
  "once_cell",
  "regex",
  "regex-syntax 0.8.5",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "thiserror 1.0.69",
  "tracing",
  "unicode-ident",
@@ -3203,6 +3188,20 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
+[[package]]
+name = "pathfinding"
+version = "4.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301ad6aa19104eeb9af172b3d6a4ab8a5ea26234890baf2fcb1cbbc3f05f674b"
+dependencies = [
+ "deprecate-until",
+ "indexmap",
+ "integer-sqrt",
+ "num-traits",
+ "rustc-hash 2.1.0",
+ "thiserror 2.0.3",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
@@ -3570,21 +3569,21 @@ checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
 [[package]]
 name = "rstest"
-version = "0.23.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a2c585be59b6b5dd66a9d2084aa1d8bd52fbdb806eafdeffb52791147862035"
+checksum = "03e905296805ab93e13c1ec3a03f4b6c4f35e9498a3d5fa96dc626d22c03cd89"
 dependencies = [
- "futures",
  "futures-timer",
+ "futures-util",
  "rstest_macros",
  "rustc_version",
 ]
 
 [[package]]
 name = "rstest_macros"
-version = "0.23.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "825ea780781b15345a146be27eaefb05085e337e869bff01b4306a4fd4a9ad5a"
+checksum = "ef0053bbffce09062bee4bcc499b0fbe7a57b879f1efe088d6d8d4c7adcdef9b"
 dependencies = [
  "cfg-if",
  "glob",
@@ -3604,6 +3603,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -4320,7 +4325,7 @@ dependencies = [
  "parking_lot",
  "profiling",
  "raw-window-handle",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "smallvec",
  "thiserror 1.0.69",
  "wgpu-hal",
@@ -4362,7 +4367,7 @@ dependencies = [
  "range-alloc",
  "raw-window-handle",
  "renderdoc-sys",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "smallvec",
  "thiserror 1.0.69",
  "wasm-bindgen",

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "hexlab"
 authors = ["Kristofers Solo <dev@kristofers.xyz>"]
-version = "0.5.0"
+version = "0.6.1"
 edition = "2021"
 description = "A hexagonal maze generation and manipulation library"
 repository = "https://github.com/kristoferssolo/hexlab"
@@ -26,6 +26,7 @@ thiserror = "2.0"
 bevy = { version = "0.15", optional = true }
 bevy_utils = { version = "0.15", optional = true }
 glam = { version = "0.29", optional = true }
+pathfinding = { version = "4.13", optional = true }
 
 
 [dependencies.bevy_reflect]
@@ -36,7 +37,7 @@ features = ["glam"]
 
 [dev-dependencies]
 claims = "0.8"
-rstest = "0.23"
+rstest = "0.24"
 
 [features]
 default = []
@@ -48,7 +49,8 @@ bevy_reflect = [
   "hexx/bevy_reflect",
   "dep:glam",
 ]
-full = ["serde", "bevy"]
+pathfinding = ["dep:pathfinding"]
+full = ["serde", "bevy", "pathfinding"]
 
 [profile.dev]
 opt-level = 1 # Better compile times with some optimization

README.md

@@ -42,7 +42,7 @@ fn main() {
         .with_radius(5)
         .build()
         .expect("Failed to create maze");
-    println!("Maze size: {}", maze.len());
+    println!("Maze size: {}", maze.count());
 }
 ```
 

src/builder.rs

@@ -20,7 +20,7 @@ use hexx::Hex;
 ///
 /// // A radius of 5 creates 61 hexagonal tiles
 /// assert!(!maze.is_empty());
-/// assert_eq!(maze.len(), 91);
+/// assert_eq!(maze.count(), 91);
 /// ```
 ///
 /// Using a seed for reproducible results:
@@ -40,7 +40,7 @@ use hexx::Hex;
 ///     .expect("Failed to create maze");
 ///
 /// // Same seed should produce identical mazes
-/// assert_eq!(maze1.len(), maze2.len());
+/// assert_eq!(maze1.count(), maze2.count());
 /// assert_eq!(maze1, maze2);
 /// ```
 ///
@@ -190,7 +190,7 @@ pub fn create_hex_maze(radius: u16) -> Maze {
 #[cfg(test)]
 mod test {
     use super::*;
-    use claims::assert_gt;
+    use claims::{assert_gt, assert_some};
     use rstest::rstest;
 
     #[test]
@@ -211,18 +211,18 @@ mod test {
     #[case(100, 30301)]
     fn create_hex_maze_various_radii(#[case] radius: u16, #[case] expected_size: usize) {
         let maze = create_hex_maze(radius);
-        assert_eq!(maze.len(), expected_size);
+        assert_eq!(maze.count(), expected_size);
     }
 
     #[test]
     fn create_hex_maze_large_radius() {
         let large_radius = 1000;
         let maze = create_hex_maze(large_radius);
-        assert_gt!(maze.len(), 0);
+        assert_gt!(maze.count(), 0);
 
         // Calculate expected size for this radius
         let expected_size = 3 * (large_radius as usize).pow(2) + 3 * large_radius as usize + 1;
-        assert_eq!(maze.len(), expected_size);
+        assert_eq!(maze.count(), expected_size);
     }
 
     #[test]
@@ -249,8 +249,8 @@ mod test {
             Hex::new(0, -2),
             Hex::new(1, -2),
         ];
-        for pos in expected_positions.iter() {
+        for pos in &expected_positions {
-            assert!(maze.get(pos).is_some(), "Expected tile at {:?}", pos);
+            assert_some!(maze.get(pos), "Expected tile at {pos:?}");
         }
     }
 }

src/errors.rs

@@ -1,6 +1,8 @@
-use hexx::Hex;
+use hexx::{EdgeDirection, Hex};
 use thiserror::Error;
 
+use crate::Tile;
+
 #[derive(Debug, Error, PartialEq, Eq)]
 pub enum MazeBuilderError {
     /// Occurs when attempting to build a maze without specifying a radius.
@@ -18,6 +20,22 @@ pub enum MazeBuilderError {
 
 #[derive(Debug, Error, PartialEq, Eq)]
 pub enum MazeError {
+    /// Error when attempting to access or modify a tile at a non-existent coordinate.
     #[error("Invalid coordinate: {0:?}")]
     InvalidCoordinate(Hex),
+
+    /// Error when a tile's internal position doesn't match its insertion coordinate.
+    #[error("Tile position ({tile_pos:?}) does not match insertion coordinates ({insert_pos:?})")]
+    PositionMismatch { tile_pos: Hex, insert_pos: Hex },
+
+    /// Error when attempting to insert a tile at an already occupied position.
+    #[error("A tile {old_tile:?} already exists at position {pos:?}")]
+    TileAlreadyExists { pos: Hex, old_tile: Tile },
+
+    /// Error when a wall operation fails at the specified coordinate and direction.
+    #[error("Cannot add wall at {coord:?} in direction {direction:?}")]
+    WallOperationFailed {
+        coord: Hex,
+        direction: EdgeDirection,
+    },
 }

src/generator/backtrack.rs

@@ -44,6 +44,7 @@ fn recursive_backtrack<R: Rng>(
 mod test {
     use super::*;
     use crate::builder::create_hex_maze;
+    use claims::assert_some;
     use rstest::rstest;
 
     #[rstest]
@@ -72,7 +73,7 @@ mod test {
         recursive_backtrack(&mut maze, start, &mut visited, &mut rng);
 
         for &pos in maze.keys() {
-            let walls = maze.get_walls(&pos).unwrap();
+            let walls = assert_some!(maze.get_walls(&pos));
             assert!(
                 walls.count() < 6,
                 "At least one wall should be removed for each tile"
@@ -100,12 +101,16 @@ mod test {
             for dir in EdgeDirection::ALL_DIRECTIONS {
                 let neighbor = current + dir;
                 if let Some(walls) = maze.get_walls(&current) {
-                    if !walls.contains(&dir) && maze.get(&neighbor).is_some() {
+                    if !walls.contains(dir) && maze.get(&neighbor).is_some() {
                         to_visit.push(neighbor);
                     }
                 }
             }
         }
-        assert_eq!(connected.len(), maze.len(), "All tiles should be connected");
+        assert_eq!(
+            connected.len(),
+            maze.count(),
+            "All tiles should be connected"
+        );
     }
 }

src/generator/mod.rs

@@ -15,6 +15,7 @@ pub enum GeneratorType {
     #[default]
     RecursiveBacktracking,
 }
+
 impl GeneratorType {
     pub fn generate(&self, maze: &mut Maze, start_pos: Option<Hex>, seed: Option<u64>) {
         match self {

src/lib.rs

@@ -20,7 +20,7 @@
 //!     .build()
 //!     .expect("Failed to create maze");
 //!
-//! assert_eq!(maze.len(), 37); // A radius of 3 should create 37 tiles
+//! assert_eq!(maze.count(), 37); // A radius of 3 should create 37 tiles
 //!```
 //!
 //! Customizing maze generation:
@@ -45,13 +45,15 @@
 //!
 //! let mut walls = Walls::empty();
 //! assert!(!walls.insert(EdgeDirection::FLAT_NORTH));
-//! assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+//! assert!(walls.contains(EdgeDirection::FLAT_NORTH));
-//! assert!(!walls.contains(&EdgeDirection::FLAT_SOUTH));
+//! assert!(!walls.contains(EdgeDirection::FLAT_SOUTH));
 //!```
 mod builder;
 pub mod errors;
 mod generator;
 mod maze;
+#[cfg(feature = "pathfinding")]
+mod pathfinding;
 mod tile;
 pub mod traits;
 mod walls;

src/maze.rs

@@ -34,7 +34,7 @@ impl Maze {
     /// let maze = Maze::new();
     ///
     /// assert!(maze.is_empty());
-    /// assert_eq!(maze.len(), 0);
+    /// assert_eq!(maze.count(), 0);
     /// ```
     #[inline]
     #[must_use]
@@ -69,14 +69,7 @@ impl Maze {
         self.0.insert(coords, tile)
     }
 
-    /// Adds a new tile at the specified coordinates.
+    /// Adds a new tile at the specified coordinates. It is recommended to use [`insert`].
-    ///
-    /// If the map did not have this key present, [`None`] is returned.
-    ///
-    /// If the map did have this key present, the value is updated, and the old
-    /// value is returned.
-    ///
-    /// It is recommended to use [`insert`].
     ///
     /// [`insert`]: Maze::insert
     ///
@@ -85,21 +78,50 @@ impl Maze {
     /// - `coords` - The hexagonal coordinates where the tile should be added.
     /// - `tile` - The tile to insert to.
     ///
+    /// # Errors
+    ///
+    /// Returns [`MazeError::PositionMismatch`] if the tile's position doesn't match the insertion coordinates.
+    /// Returns [`MazeError::TileAlreadyExists`] if a tile already exists at the specified coordinates.
+    ///
     /// # Examples
     ///
     /// ```
     /// use hexlab::prelude::*;
     ///
     /// let mut maze = Maze::new();
-    /// let coord = Hex::ZERO;
-    /// let tile1 = Tile::new(coord);
-    /// let tile2 = Tile::new(Hex::new(1, 1));
     ///
-    /// assert_eq!(maze.insert_with_tile(coord, tile1.clone()), None);
+    /// assert_eq!(
-    /// assert_eq!(maze.insert_with_tile(coord, tile2), Some(tile1));
+    ///     maze.insert_with_tile(Hex::new(2, 2), Tile::new(Hex::ZERO)),
+    ///     Err(MazeError::PositionMismatch {
+    ///         tile_pos: Hex::ZERO,
+    ///         insert_pos: Hex::new(2, 2)
+    ///     })
+    /// );
+    /// let tile = Tile::new(Hex::ZERO);
+    /// assert_eq!(maze.insert_with_tile(Hex::ZERO, tile.clone()), Ok(tile.clone()));
+    /// assert_eq!(
+    ///     maze.insert_with_tile(Hex::ZERO, tile.clone()),
+    ///     Err(MazeError::TileAlreadyExists {
+    ///         pos: Hex::ZERO,
+    ///         old_tile: tile
+    ///     })
+    /// );
     /// ```
-    pub fn insert_with_tile(&mut self, coords: Hex, tile: Tile) -> Option<Tile> {
+    pub fn insert_with_tile(&mut self, coords: Hex, tile: Tile) -> Result<Tile, MazeError> {
-        self.0.insert(coords, tile)
+        if tile.pos != coords {
+            return Err(MazeError::PositionMismatch {
+                tile_pos: tile.pos,
+                insert_pos: coords,
+            });
+        }
+        self.0
+            .insert(coords, tile.clone())
+            .map_or(Ok(tile), |old_tile| {
+                Err(MazeError::TileAlreadyExists {
+                    pos: coords,
+                    old_tile,
+                })
+            })
     }
 
     /// Returns a reference to the tile at the specified coordinates.
@@ -149,7 +171,7 @@ impl Maze {
     ///
     /// maze.add_tile_wall(&coord, EdgeDirection::FLAT_NORTH);
     /// let walls = maze.get_walls(&coord).unwrap();
-    /// assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+    /// assert!(walls.contains(EdgeDirection::FLAT_NORTH));
     /// ```
     #[inline]
     #[must_use]
@@ -190,17 +212,17 @@ impl Maze {
     /// use hexlab::prelude::*;
     ///
     /// let mut maze = Maze::new();
-    /// assert_eq!(maze.len(), 0);
+    /// assert_eq!(maze.count(), 0);
     ///
     /// maze.insert(Hex::new(0, 0));
-    /// assert_eq!(maze.len(), 1);
+    /// assert_eq!(maze.count(), 1);
     ///
     /// maze.insert(Hex::new(1, -1));
-    /// assert_eq!(maze.len(), 2);
+    /// assert_eq!(maze.count(), 2);
     /// ```
     #[inline]
     #[must_use]
-    pub fn len(&self) -> usize {
+    pub fn count(&self) -> usize {
         self.0.len()
     }
 
@@ -252,7 +274,7 @@ impl Maze {
     ///
     /// // Check that the wall was added
     /// let walls = maze.get_walls(&Hex::ZERO).unwrap();
-    /// assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+    /// assert!(walls.contains(EdgeDirection::FLAT_NORTH));
     /// assert_eq!(walls.count(), 1);
     ///
     /// // Adding the same wall again should return true (no change)
@@ -300,7 +322,7 @@ impl Maze {
     /// maze.remove_tile_wall(&coord, EdgeDirection::FLAT_NORTH);
     ///
     /// let walls = maze.get_walls(&coord).unwrap();
-    /// assert!(!walls.contains(&EdgeDirection::FLAT_NORTH));
+    /// assert!(!walls.contains(EdgeDirection::FLAT_NORTH));
     /// ```
     pub fn remove_tile_wall(
         &mut self,

src/pathfinding.rs

@@ -0,0 +1,84 @@
+//! Maze pathfinding implementation for hexagonal grids.
+//!
+//! This module provides functionality for finding paths through a hexagonal maze
+//! using the A* pathfinding algorithm. The maze is represented as a collection of
+//! hexagonal cells, where each cell may have walls on any of its six edges.
+//!
+//! # Examples
+//!
+//! ```
+//! use hexlab::prelude::*;
+//!
+//! let maze = MazeBuilder::new()
+//!     .with_radius(3)
+//!     .with_seed(12345)
+//!     .build()
+//!     .expect("Failed to create maze");
+//! assert!(maze.find_path(Hex::ZERO, Hex::new(-1, 3)).is_some());
+//! ```
+//!
+//! # Implementation Details
+//!
+//! The pathfinding algorithm uses Manhattan distance as a heuristic and considers
+//! walls between cells when determining valid paths. Each step between adjacent
+//! cells has a cost of 1.
+use hexx::{EdgeDirection, Hex};
+use pathfinding::prelude::*;
+
+use crate::Maze;
+
+impl Maze {
+    #[must_use]
+    /// Finds the shortest path between two hexagonal positions in the maze using A* pathfinding.
+    ///
+    /// This function calculates the optimal path while taking into account walls between cells.
+    /// The path cost between adjacent cells is always 1, and Manhattan distance is used as the
+    /// heuristic for pathfinding.
+    ///
+    /// # Arguments
+    ///
+    /// * `from` - The starting hexagonal position
+    /// * `to` - The target hexagonal position
+    ///
+    /// # Returns
+    ///
+    /// * `Some(Vec<Hex>)` - A vector of hexagonal positions representing the path from start to target
+    /// * `None` - If no valid path exists between the positions
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hexlab::prelude::*;
+    ///
+    /// let maze = MazeBuilder::new()
+    ///     .with_radius(3)
+    ///     .with_seed(12345)
+    ///     .build()
+    ///     .expect("Failed to create maze");
+    /// assert!(maze.find_path(Hex::ZERO, Hex::new(-1, 3)).is_some());
+    /// ```
+    pub fn find_path(&self, from: Hex, to: Hex) -> Option<Vec<Hex>> {
+        let successors = |pos: &Hex| {
+            {
+                EdgeDirection::ALL_DIRECTIONS.iter().filter_map(|&dir| {
+                    let neighbor = pos.neighbor(dir);
+                    if let Some(current_tile) = self.get(pos) {
+                        if self.get(&neighbor).is_some() && !current_tile.walls.contains(dir) {
+                            return Some((neighbor, 1)); // Cost of 1 for each step
+                        }
+                    }
+                    None
+                })
+            }
+            .collect::<Vec<_>>()
+        };
+
+        let heuristic = |pos: &Hex| {
+            // Manhatan distance
+            let diff = *pos - to;
+            (diff.x.abs() + diff.y.abs() + diff.z().abs()) / 2
+        };
+
+        astar(&from, successors, heuristic, |pos| *pos == to).map(|(path, _)| path)
+    }
+}

src/tile.rs

@@ -236,7 +236,7 @@ mod test {
             let layout = HexLayout::default();
             let tile = Tile::new(Hex::new(1, 0));
             let vec2 = tile.to_vec2(&layout);
-            assert_eq!(vec2, Vec2::new(1.5, -0.8660254));
+            assert_eq!(vec2, Vec2::new(1.5, -0.866_025_4));
         }
 
         #[test]
@@ -244,7 +244,7 @@ mod test {
             let layout = HexLayout::default();
             let tile = Tile::new(Hex::new(0, 1));
             let vec3 = tile.to_vec3(&layout);
-            assert_eq!(vec3, Vec3::new(0.0, 0.0, -1.7320508));
+            assert_eq!(vec3, Vec3::new(0.0, 0.0, -1.732_050_8));
         }
     }
 }

src/walls.rs

@@ -115,7 +115,7 @@ impl Walls {
     #[inline]
     pub fn insert<T>(&mut self, direction: T) -> bool
     where
-        T: Into<Self> + Copy,
+        T: Into<Self>,
     {
         let mask = direction.into().0;
         let was_present = self.0 & mask != 0;
@@ -152,7 +152,7 @@ impl Walls {
     #[inline]
     pub fn remove<T>(&mut self, direction: T) -> bool
     where
-        T: Into<Self> + Copy,
+        T: Into<Self>,
     {
         let mask = direction.into().0;
         let was_present = self.0 & mask != 0;
@@ -174,15 +174,15 @@ impl Walls {
     /// let mut walls = Walls::empty();
     /// walls.insert(EdgeDirection::FLAT_NORTH);
     ///
-    /// assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+    /// assert!(walls.contains(EdgeDirection::FLAT_NORTH));
-    /// assert!(!walls.contains(&EdgeDirection::FLAT_SOUTH));
+    /// assert!(!walls.contains(EdgeDirection::FLAT_SOUTH));
     /// ```
     #[inline]
-    pub fn contains<T>(&self, direction: &T) -> bool
+    pub fn contains<T>(&self, direction: T) -> bool
     where
-        T: Into<Self> + Copy,
+        T: Into<Self>,
     {
-        self.0 & (*direction).into().0 != 0
+        self.0 & direction.into().0 != 0
     }
 
     /// Returns the raw bit representation of the walls
@@ -319,7 +319,7 @@ impl Walls {
     /// let mut walls = Walls::empty();
     /// walls.fill([EdgeDirection::FLAT_NORTH ,EdgeDirection::FLAT_SOUTH, EdgeDirection::FLAT_SOUTH_EAST]);
     ///
-    /// assert!(walls.contains(&EdgeDirection::FLAT_SOUTH));
+    /// assert!(walls.contains(EdgeDirection::FLAT_SOUTH));
     /// assert_eq!(walls.count(), 3);
     /// ```
     #[inline]
@@ -375,7 +375,7 @@ mod test {
         let walls = Walls::all_directions();
         assert!(walls.is_enclosed());
         assert!(!walls.is_empty());
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // as_bits
@@ -389,7 +389,7 @@ mod test {
     fn as_bits_single_wall() {
         let mut walls = Walls::empty();
         walls.insert(EdgeDirection::FLAT_NORTH);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
     }
 
     #[test]
@@ -397,13 +397,13 @@ mod test {
         let mut walls = Walls::empty();
         walls.insert(EdgeDirection::FLAT_NORTH);
         walls.insert(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
     fn as_bits_all_walls() {
         let walls = Walls::new();
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // new
@@ -411,7 +411,7 @@ mod test {
     fn new_created_closed_walls() {
         let walls = Walls::new();
         assert!(walls.is_enclosed());
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // empty
@@ -427,7 +427,7 @@ mod test {
     fn insert_single_wall() {
         let mut walls = Walls::empty();
         walls.insert(EdgeDirection::FLAT_NORTH);
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
         assert_eq!(walls.count(), 1);
     }
 
@@ -436,7 +436,7 @@ mod test {
     fn remove_existing_wall() {
         let mut walls = Walls::new();
         assert!(walls.remove(EdgeDirection::FLAT_NORTH));
-        assert!(!walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(!walls.contains(EdgeDirection::FLAT_NORTH));
     }
 
     #[test]
@@ -452,14 +452,14 @@ mod test {
     fn toggle_wall() {
         let mut walls = Walls::empty();
         assert!(!walls.toggle(EdgeDirection::FLAT_NORTH));
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
     }
 
     #[test]
     fn toggle_removes_wall() {
         let mut walls = Walls::new();
         assert!(walls.toggle(EdgeDirection::FLAT_NORTH));
-        assert!(!walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(!walls.contains(EdgeDirection::FLAT_NORTH));
     }
 
     // fill
@@ -467,8 +467,8 @@ mod test {
     fn fill_adds_multiple_walls() {
         let mut walls = Walls::empty();
         walls.fill([EdgeDirection::FLAT_NORTH, EdgeDirection::FLAT_SOUTH]);
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
-        assert!(walls.contains(&EdgeDirection::FLAT_SOUTH));
+        assert!(walls.contains(EdgeDirection::FLAT_SOUTH));
         assert_eq!(walls.count(), 2);
     }
 
@@ -477,31 +477,31 @@ mod test {
         let mut walls = Walls::empty();
         walls.insert(EdgeDirection::FLAT_NORTH);
         walls.fill([EdgeDirection::FLAT_SOUTH, EdgeDirection::FLAT_SOUTH_EAST]);
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
-        assert!(walls.contains(&EdgeDirection::FLAT_SOUTH));
+        assert!(walls.contains(EdgeDirection::FLAT_SOUTH));
-        assert!(walls.contains(&EdgeDirection::FLAT_SOUTH_EAST));
+        assert!(walls.contains(EdgeDirection::FLAT_SOUTH_EAST));
         assert_eq!(walls.count(), 3);
     }
 
     #[test]
     fn from_edge_direction_conversion() {
         let walls: Walls = EdgeDirection::FLAT_NORTH.into();
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
         assert_eq!(walls.count(), 1);
     }
 
     #[test]
     fn from_u8_conversion() {
         let walls: Walls = 0u8.into();
-        assert!(walls.contains(&EdgeDirection::FLAT_SOUTH_EAST));
+        assert!(walls.contains(EdgeDirection::FLAT_SOUTH_EAST));
         assert_eq!(walls.count(), 1);
     }
 
     #[test]
     fn from_array_conversion() {
         let walls: Walls = [EdgeDirection::FLAT_NORTH, EdgeDirection::FLAT_SOUTH].into();
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
-        assert!(walls.contains(&EdgeDirection::FLAT_SOUTH));
+        assert!(walls.contains(EdgeDirection::FLAT_SOUTH));
         assert_eq!(walls.count(), 2);
     }
 
@@ -520,7 +520,7 @@ mod test {
     fn default_creates_closed_walls() {
         let walls = Walls::default();
         assert!(walls.is_enclosed());
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     #[test]
@@ -532,8 +532,8 @@ mod test {
         ];
         let walls: Walls = directions.into_iter().collect();
         assert_eq!(walls.count(), 2);
-        assert!(walls.contains(&EdgeDirection::FLAT_NORTH));
+        assert!(walls.contains(EdgeDirection::FLAT_NORTH));
-        assert!(walls.contains(&EdgeDirection::FLAT_SOUTH));
+        assert!(walls.contains(EdgeDirection::FLAT_SOUTH));
     }
 
     #[test]
@@ -542,53 +542,53 @@ mod test {
 
         // Test single bit operations
         walls.insert(EdgeDirection::FLAT_NORTH);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
 
         walls.insert(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
 
         // Test removing middle bit
         walls.insert(EdgeDirection::FLAT_SOUTH_EAST);
-        assert_eq!(walls.as_bits(), 0b010011);
+        assert_eq!(walls.as_bits(), 0b01_0011);
         walls.remove(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b010001);
+        assert_eq!(walls.as_bits(), 0b01_0001);
     }
 
     // From<EdgeDirection> tests
     #[test]
     fn from_edge_direction_flat_south_east() {
         let walls = Walls::from(EdgeDirection::FLAT_SOUTH_EAST);
-        assert_eq!(walls.as_bits(), 0b000001);
+        assert_eq!(walls.as_bits(), 0b00_0001);
     }
 
     #[test]
     fn from_edge_direction_flat_south() {
         let walls = Walls::from(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b000010);
+        assert_eq!(walls.as_bits(), 0b00_0010);
     }
 
     #[test]
     fn from_edge_direction_flat_south_west() {
         let walls = Walls::from(EdgeDirection::FLAT_SOUTH_WEST);
-        assert_eq!(walls.as_bits(), 0b000100);
+        assert_eq!(walls.as_bits(), 0b00_0100);
     }
 
     #[test]
     fn from_edge_direction_flat_north_west() {
         let walls = Walls::from(EdgeDirection::FLAT_NORTH_WEST);
-        assert_eq!(walls.as_bits(), 0b001000);
+        assert_eq!(walls.as_bits(), 0b00_1000);
     }
 
     #[test]
     fn from_edge_direction_flat_north() {
         let walls = Walls::from(EdgeDirection::FLAT_NORTH);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
     }
 
     #[test]
     fn from_edge_direction_flat_east() {
         let walls = Walls::from(EdgeDirection::FLAT_NORTH_EAST);
-        assert_eq!(walls.as_bits(), 0b100000);
+        assert_eq!(walls.as_bits(), 0b10_0000);
     }
 
     // FromIterator tests
@@ -603,7 +603,7 @@ mod test {
         let walls = vec![EdgeDirection::FLAT_SOUTH]
             .into_iter()
             .collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b000010);
+        assert_eq!(walls.as_bits(), 0b00_0010);
     }
 
     #[test]
@@ -611,7 +611,7 @@ mod test {
         let walls = vec![EdgeDirection::FLAT_NORTH, EdgeDirection::FLAT_SOUTH]
             .into_iter()
             .collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
@@ -623,13 +623,13 @@ mod test {
         ]
         .into_iter()
         .collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
     fn from_iterator_all_directions() {
         let walls = EdgeDirection::iter().collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // From<[EdgeDirection; N]> tests
@@ -642,13 +642,13 @@ mod test {
     #[test]
     fn from_array_single() {
         let walls = Walls::from([EdgeDirection::FLAT_NORTH]);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
     }
 
     #[test]
     fn from_array_multiple() {
         let walls = Walls::from([EdgeDirection::FLAT_NORTH, EdgeDirection::FLAT_SOUTH]);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
@@ -658,7 +658,7 @@ mod test {
             EdgeDirection::FLAT_NORTH,
             EdgeDirection::FLAT_SOUTH,
         ]);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
@@ -671,6 +671,6 @@ mod test {
             EdgeDirection::FLAT_SOUTH_WEST,
             EdgeDirection::FLAT_NORTH_WEST,
         ]);
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 }

tests/builder.rs

@@ -10,7 +10,7 @@ use rstest::rstest;
 #[case(5, 91)]
 fn maze_size(#[case] radius: u16, #[case] expected_size: usize) {
     let maze = assert_ok!(MazeBuilder::new().with_radius(radius).build());
-    assert_eq!(maze.len(), expected_size);
+    assert_eq!(maze.count(), expected_size);
 }
 
 #[test]
@@ -67,28 +67,24 @@ fn maze_connectivity() {
     let maze = assert_ok!(MazeBuilder::new().with_radius(3).build());
 
     // Helper function to count accessible neighbors
-    fn count_accessible_neighbors(maze: &Maze, pos: Hex) -> usize {
+    let count_accessible_neighbors = |pos: Hex| -> usize {
         hexx::EdgeDirection::ALL_DIRECTIONS
             .iter()
             .filter(|&&dir| {
                 let neighbor = pos + dir;
-                if let Some(walls) = maze.get_walls(&pos) {
+                maze.get_walls(&pos)
-                    !walls.contains(&dir) && maze.get(&neighbor).is_some()
+                    .is_some_and(|walls| !walls.contains(dir) && maze.get(&neighbor).is_some())
-                } else {
-                    false
-                }
             })
             .count()
-    }
+    };
 
     // Check that each tile has at least one connection
     for &pos in maze.keys() {
-        let accessible_neighbors = count_accessible_neighbors(&maze, pos);
+        let accessible_neighbors = count_accessible_neighbors(pos);
-        claims::assert_gt!(
+        assert_gt!(
             accessible_neighbors,
             0,
-            "Tile at {:?} has no accessible neighbors",
+            "Tile at {pos:?} has no accessible neighbors",
-            pos
         );
     }
 }
@@ -96,10 +92,9 @@ fn maze_connectivity() {
 #[test]
 fn maze_boundaries() {
     let radius = 3;
-    let maze = MazeBuilder::new()
+    let maze = assert_ok!(MazeBuilder::new().with_radius(radius).build());
-        .with_radius(radius as u16)
+
-        .build()
+    let radius = i32::from(radius);
-        .unwrap();
 
     // Test that tiles exist within the radius
     for q in -radius..=radius {
@@ -108,8 +103,7 @@ fn maze_boundaries() {
             if q.abs() + r.abs() <= radius {
                 assert!(
                     maze.get(&pos).is_some(),
-                    "Expected tile at {:?} to exist",
+                    "Expected tile at {pos:?} to exist",
-                    pos
                 );
             }
         }
@@ -126,5 +120,5 @@ fn generate_maze_with_different_types(#[case] generator: GeneratorType) {
         .with_generator(generator)
         .build());
 
-    assert_gt!(maze.len(), 0);
+    assert_gt!(maze.count(), 0);
 }

tests/generator.rs

@@ -1,3 +1,4 @@
+use claims::assert_some;
 use hexlab::prelude::*;
 use rstest::rstest;
 
@@ -19,11 +20,11 @@ fn generator_type(
             }
         }
     }
-    let initial_size = maze.len();
+    let initial_size = maze.count();
 
     generator.generate(&mut maze, start_pos, seed);
 
-    assert_eq!(maze.len(), initial_size, "Maze size should not change");
+    assert_eq!(maze.count(), initial_size, "Maze size should not change");
 
     // Check maze connectivity
     let start = start_pos.unwrap_or(Hex::ZERO);
@@ -36,21 +37,20 @@ fn generator_type(
         for dir in EdgeDirection::ALL_DIRECTIONS {
             let neighbor = current + dir;
             if let Some(walls) = maze.get_walls(&current) {
-                if !walls.contains(&dir) && maze.get(&neighbor).is_some() {
+                if !walls.contains(dir) && maze.get(&neighbor).is_some() {
                     to_visit.push(neighbor);
                 }
             }
         }
     }
-    assert_eq!(visited.len(), maze.len(), "All tiles should be connected");
+    assert_eq!(visited.len(), maze.count(), "All tiles should be connected");
 
     // Check that each tile has at least one open wall
     for &pos in maze.keys() {
-        let walls = maze.get_walls(&pos).unwrap();
+        let walls = assert_some!(maze.get_walls(&pos));
         assert!(
             walls.count() < 6,
-            "Tile at {:?} should have at least one open wall",
+            "Tile at {pos:?} should have at least one open wall",
-            pos
         );
     }
 }

tests/maze.rs

@@ -1,3 +1,4 @@
+use claims::assert_some;
 use hexlab::prelude::*;
 
 #[test]
@@ -7,12 +8,11 @@ fn hex_maze_creation_and_basic_operations() {
 
     let center = Hex::ZERO;
     maze.insert(center);
-    assert_eq!(maze.len(), 1);
+    assert_eq!(maze.count(), 1);
     assert!(!maze.is_empty());
 
-    let tile = maze.get(&center);
+    let tile = assert_some!(maze.get(&center));
-    assert!(tile.is_some());
+    assert_eq!(tile.pos(), center);
-    assert_eq!(tile.unwrap().pos(), center);
 }
 
 #[test]
@@ -26,7 +26,7 @@ fn hex_maze_wall_operations() {
         let _ = maze.add_tile_wall(&center, direction);
     }
 
-    let walls = maze.get_walls(&center).unwrap();
+    let walls = assert_some!(maze.get_walls(&center));
     assert_eq!(walls.count(), 6);
 
     // Remove walls
@@ -34,7 +34,7 @@ fn hex_maze_wall_operations() {
         let _ = maze.remove_tile_wall(&center, direction);
     }
 
-    let walls = maze.get_walls(&center).unwrap();
+    let walls = assert_some!(maze.get_walls(&center));
     assert_eq!(walls.count(), 0);
 }
 
@@ -47,7 +47,7 @@ fn hex_maze_multiple_tiles() {
         maze.insert(tile);
     }
 
-    assert_eq!(maze.len(), tiles.len());
+    assert_eq!(maze.count(), tiles.len());
 
     for &tile in &tiles {
         assert!(maze.get(&tile).is_some());

tests/pathfinding.rs

@@ -0,0 +1,79 @@
+use claims::*;
+use hexlab::MazeBuilder;
+use hexx::{hex, EdgeDirection, Hex};
+
+#[test]
+fn basic_path() {
+    let maze = assert_ok!(MazeBuilder::new().with_seed(12345).with_radius(5).build());
+
+    let start = Hex::new(0, 0);
+    let goal = Hex::new(2, 0);
+
+    assert_some_eq!(
+        maze.find_path(start, goal),
+        vec![start, hex(1, 0), hex(1, 1), hex(2, 1), goal]
+    );
+}
+
+#[test]
+fn path_with_walls() {
+    let mut maze = assert_ok!(MazeBuilder::new().with_seed(12345).with_radius(5).build());
+    let start = Hex::new(0, 0);
+    let goal = Hex::new(2, 0);
+
+    // Block direct path with wall
+    assert_ok!(maze.add_tile_wall(&start, EdgeDirection::FLAT_SOUTH));
+
+    // Should find alternative path or no path
+    let path = maze.find_path(start, goal);
+    if let Some(path) = path {
+        // If path exists, verify it's valid
+        assert!(path.len() > 3); // Should be longer than direct path
+        assert_eq!(path.first(), Some(&start));
+        assert_eq!(path.last(), Some(&goal));
+    }
+}
+
+#[test]
+fn path_to_self() {
+    let maze = assert_ok!(MazeBuilder::new().with_seed(12345).with_radius(5).build());
+    let pos = Hex::new(0, 0);
+
+    assert_some_eq!(maze.find_path(pos, pos), vec![pos]);
+}
+
+#[test]
+fn no_path_exists() {
+    let mut maze = assert_ok!(MazeBuilder::new().with_seed(12345).with_radius(5).build());
+    let start = Hex::new(0, 0);
+    let goal = Hex::new(2, 0);
+
+    // Surround start with walls
+    for dir in EdgeDirection::ALL_DIRECTIONS {
+        assert_ok!(maze.add_tile_wall(&start, dir));
+    }
+
+    assert_none!(maze.find_path(start, goal));
+}
+
+#[test]
+fn path_in_larger_maze() {
+    let maze = assert_ok!(MazeBuilder::new().with_seed(12345).with_radius(10).build());
+    let start = Hex::new(-5, -5);
+    let goal = Hex::new(5, 5);
+
+    let path = assert_some!(maze.find_path(start, goal));
+
+    // Basic path properties
+    assert_eq!(path.first(), Some(&start));
+    assert_eq!(path.last(), Some(&goal));
+
+    // Path should be continuous
+    for window in path.windows(2) {
+        let current = window[0];
+        let next = window[1];
+        assert!(EdgeDirection::ALL_DIRECTIONS
+            .iter()
+            .any(|&dir| current.neighbor(dir) == next));
+    }
+}