         g            (graph-to-minimum-spanning-tree fcg)
         more-edges   (additional-edges min-width min-height room-centers g)
         g            (concat g more-edges)
-        ;; reduce over g
+        ;; set of room centers that are junction rooms
+        junction-rooms (find-junction-rooms g)
+        ;; merge room cells to canvas, skipping junction rooms
+        cells        (reduce (fn [cells room-bound]
+                               (println "room-bound" room-bound)
+                               (if (contains? junction-rooms (room-bounds-to-center room-bound))
+                                 cells
+                                 (let [room-cellsxy (apply room-to-cellsxy room-bound)]
+                                   (println "room-cellsxy" room-cellsxy)
+                                   (apply merge-with-canvas cells room-cellsxy))))
+                             (canvas width height)
+                             room-bounds)
+        ;; reduce over g, merging corridor cells to canvas
         cells        (reduce (fn [cells [start goal]]
-                               (let [points (make-corridor-points cells room-centers-to-room-bounds start goal)]
+                               (let [points (make-corridor-points cells room-centers-to-room-bounds junction-rooms start goal)]
                                  (println "corridor points" points)
                                  (apply merge-with-canvas cells (points-to-corridor points))))
-                             (apply merge-with-canvas (canvas width height) rooms)
+                             cells
                              g)
         upstairs     (conj [(first room-centers)] {:type :up-stairs})
         downstairs   (conj [(last room-centers)] {:type :down-stairs})]

                                      [x y (+ x width) (+ y height)]))
                                    (range columns)))
                             (range rows))
        rooms        (mapcat #(apply room-to-cellsxy %) room-bounds)
        room-centers-to-room-bounds
                     (reduce (fn [m room-bounds]
                               (let [[x1 y1 x2 y2] room-bounds]
                                 (assoc m [(int (/ (+ x1 x2) 2))
                                           (int (/ (+ y1 y2) 2))]
                                          room-bounds)))
                             {}
                             room-bounds)
        room-centers (keys room-centers-to-room-bounds)

    (= from-type :vertical)
      (horizontal-corner-segment from to)))

(defn make-corridor-points [cells room-centers-to-room-bounds junction-room-centers start end]
  "Finds a list of `[x y]`s comprising a corridor from `start` to `end`.
   `room-centers-to-room-bounds` is a map with `[x y]` keys and `[min-x min-y max-x max-y]` values."
  (let [start-room-bounds (get room-centers-to-room-bounds start)
        end-room-bounds   (get room-centers-to-room-bounds end)
        door-xy-1         (if (contains? junction-room-centers start)
                            start
                            (find-door start-room-bounds start end))
        door-xy-2         (if (contains? junction-room-centers end)
                            end
                            (find-door end-room-bounds end start))]
    (println "start" start)
    (println "start-room-bounds" start-room-bounds)
    (println "end" end)
