Formatting

src/game.rs

@@ -109,11 +109,7 @@ impl Display for DungeonLevel {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for y in 0..LEVEL_SIZE.1 {
             for x in 0..LEVEL_SIZE.0 {
-                write!(
+                write!(f, "{}", self.render_tile(x, y))?;
-                    f,
-                    "{}",
-                    self.render_tile(x, y)
-                )?;
             }
 
             write!(f, "\n")?;

src/rooms.rs

@@ -5,9 +5,9 @@
 //! of attempts to place rectangular rooms of random sizes and
 //! positions within the region; of these attempts, we only keep those
 //! that are spread some distance away from other existing rooms. We
-//! then use a pathfinding algorithm to navigate from one room to all
+//! then use a pathfinding algorithm to navigate from each room to the
-//! the others, leaving hallways and doors as we travel. The
+//! one generated after it, leaving hallways and doors as we travel.
-//! pathfinding algorithm is weighted to try and travel through
+//! The pathfinding algorithm is weighted to try and travel through
 //! existing rooms and hallways rather than cutting new hallways
 //! through the stone to encourage rooms to connect to other rooms
 //! near them, and it has some randomness added to its weights to
@@ -138,7 +138,9 @@ impl RoomBounds {
             );
 
             let new_room = Self { ul_corner, size };
-            if v.iter().all(|room| !room.near(&new_room, ROOM_MIN_DISTANCE)) {
+            if v.iter()
+                .all(|room| !room.near(&new_room, ROOM_MIN_DISTANCE))
+            {
                 v.push(new_room)
             }
         }
@@ -175,10 +177,12 @@ fn cut_hallways(grid: &mut Grid<DungeonTile>, rooms: &[RoomBounds], rng: &mut im
     }
 
     let size = (grid.cols(), grid.rows());
-    let origin = rooms[0].center();
 
-    for other in rooms.iter().skip(1) {
+    // Make hallways between pairs of adjacent rooms.
+    for rooms in rooms.windows(2) {
+        let (from, to) = (&rooms[0], &rooms[1]);
         let neighbors = [(-1, 0), (1, 0), (0, -1), (0, 1)];
+
         for (x, y) in pathfind(
             |node| {
                 let (x, y) = (node.0 as isize, node.1 as isize);
@@ -199,8 +203,8 @@ fn cut_hallways(grid: &mut Grid<DungeonTile>, rooms: &[RoomBounds], rng: &mut im
                         }
                     })
             },
-            origin,
+            from.center(),
-            other.center(),
+            to.center(),
         )
         .expect("graph is connected, must therefore be navigable")
         {