 
 (defn attack
   [screen {:keys [x y x-feet y-feet damage] :as attacker} victim entities]
-  (map (fn [{:keys [id last-direction] :as e}]
+  (map (fn [{:keys [id direction] :as e}]
          (cond
            (= id (:id attacker))
            (let [direction (or (when victim
                                  (u/get-direction-to-entity attacker victim))
-                               last-direction)]
+                               direction)]
              (merge e
-                    {:last-attack 0 :last-direction direction}
+                    {:last-attack 0 :direction direction}
                     (get-in e [:attacks direction])))
            (= id (:id victim))
            (if attacker

             :y-change y-change
             :x (+ x x-change)
             :y (+ y y-change))
      entity)))

(defn ^:private recover

               (merge e
                      {:last-attack 0 :health health}
                      (if (> health 0)
                        (get-in e [:hits direction])
                        (get-in e [:deads direction]))))
             e)
           :else
           e))
