diff --git a/desktop/src-common/advent/actions.clj b/desktop/src-common/advent/actions.clj
index 782bb483..8c388ccb 100644
--- a/desktop/src-common/advent/actions.clj
+++ b/desktop/src-common/advent/actions.clj
@@ -45,44 +45,53 @@
 
 (defn walk-to [entities target-id [final-x final-y]]
   (let [c (chan)
-        entity (entities target-id)
+        {start-x :x start-y :y} (entities target-id)
+        final-x (int final-x)
+        final-y (int final-y)
         path (vec (take-nth 5 (advent.pathfind/visit-all
                                (:collision (:background entities))
-                               [(int (:x entity)) (int (:y entity))]
-                               [(int final-x) (int final-y)])))
+                               [(int start-x) (int start-y)]
+                               [final-x final-y])))
         path (if (seq path)
-               (conj path [(int final-x) (int final-y)])
-               [])]
-    (doseq [[target-x target-y] path]
-      (put! (get-in entities [:actions :channel])
-            (reify
-              IAction
-              (begin [this screen entities]
-                (let [{from-x :x from-y :y :keys [left right anim]} (entities target-id)]
-                  (let [delta-x (- target-x from-x)]
-                    (assoc-in entities [target-id :anim] (if (< delta-x 0) left right)))))
+               (conj path [final-x final-y])
+               [])
+        targets-left (atom path)]
+    (if (seq path)
+      (do
+        (put! (get-in entities [:actions :channel])
+              (reify
+                IAction
+                (begin [this screen entities]
+                  entities
+                  #_(let [{from-x :x from-y :y :keys [left right anim]} (entities target-id)]
+                      (let [delta-x (- target-x from-x)]
+                        (assoc-in entities [target-id :anim] (if (< delta-x 0) left right)))))
 
-              (continue [this screen entities]
-                (let [{from-x :x from-y :y :keys [left right anim] :as target-entity} (entities target-id)]
-                  (let [delta-x (- target-x from-x)
-                        delta-y (- target-y from-y)
-                        mag (Math/sqrt (+ (* delta-x delta-x) (* delta-y delta-y)))
-                        moved-x (* 1.5 (/ delta-x mag))
-                        moved-y (* 1.5 (/ delta-y mag))]
-                    (assoc entities target-id
-                           (jump-to screen entities target-entity [(+ moved-x from-x) (+ moved-y from-y)])))))
+                (continue [this screen entities]
+                  (let [{from-x :x from-y :y :keys [left right] :as target-entity} (entities target-id)
+                        [[target-x target-y] remainder] @targets-left]
+                    (let [delta-x (- target-x from-x)
+                          delta-y (- target-y from-y)
+                          distance (dist from-x from-y target-x target-y)
+                          moved-x (* 1.5 (/ delta-x distance))
+                          moved-y (* 1.5 (/ delta-y distance))]
+                      (when (< distance 1)
+                        (swap! targets-left rest))
+                      (update-in entities [target-id]
+                                 #(assoc (jump-to screen entities % [(+ moved-x from-x) (+ moved-y from-y)])
+                                    :anim (if (< delta-x 0) left right))))))
 
-              (done? [this screen entities]
-                (let [{from-x :x from-y :y :keys [left right anim] :as target-entity} (entities target-id)]
-                  (< (dist target-x target-y from-x from-y) 1)))
+                (done? [this screen entities]
+                  (let [{from-x :x from-y :y :keys [left right anim] :as target-entity} (entities target-id)]
+                    (println final-x final-y from-x  from-y (dist final-x final-y from-x from-y))
+                    (doto (< (dist final-x final-y from-x from-y) 1) println)))
 
-              (terminate [this screen entities]
-                (doto (let [{from-x :x from-y :y :keys [left right anim] :as target-entity} (entities target-id)]
-                        (if (<= (dist final-x final-y from-x from-y) 1)
-                          (stop screen entities target-id)
-                          entities))
-                  #(put! c %))))))
-    (<!! c)))
+                (terminate [this screen entities]
+                  (let [entities (stop screen entities target-id)]
+                    (put! c entities)
+                    entities))))
+        (<!! c))
+      entities)))
 
 (defn get-text-duration [text]
   (* (count (s/split text #" ")) 0.75))