                (make-edge
                  :moving-left
                  (non-bumping-guard :right walls others)
-                 #{[:on #{:left}]}))
+                 #{[:on #{:left}]})
+               (make-edge
+                 :falling-idle-left
+                 (unsupported-guard 16 16 walls others)
+                 #{:required}))
              (make-state
                :moving-right
                {:x move-speed}
+               (bumping-transitions id :left :idle-right nil walls others)
+               (make-edge
+                 :falling-idle-right
+                 (unsupported-guard 16 16 walls others)
+                 #{[:off #{:right}]})
+               (make-edge
+                 :falling-right
+                 (unsupported-guard 16 16 walls others)
+                 #{:required})
                (make-edge
                  :idle-right
                  nil

             (make-state
               :moving-left
               {:x (- move-speed)}
               (make-edge
                 :idle-left
                 nil
                 #{[:off #{:left}]})))))

(defn make-scene-a [] (let [ids #{:ga :gb :gc :gd :ge :m}
                            walls #{[0 0 256 8]


(defn recalculate-edge [has ha index t]
  (let [edge (nth (:edges (current-state ha)) index)
        ;todo: Does this suffice? Should the transition be intersected with "the future" in any other places, eg update-scene or next-transition? Does that explain the weird interval calculated for :m in the initial setup?
        transition (update (transition-interval has ha edge)
                           :interval (fn [intvl]
                                       (iv/intersection intvl [t Infinity])))
