          ;; path. Lastly, because the each circle completes back at
          ;; the same place it started we remove these all the extra
          ;; points.
-         hits (->> circle
+         area (->> circle
                    repeat
                    (reductions interleave)
                    (take radius)
                    (interleave (repeat '([-1 -1])))
                    (apply concat)
                    (reductions (partial mapv +) coord)
-                   distinct)]
+                   (into #{}))
+         hits (->> (:players @state)
+                   (map :position)
+                   (into #{})
+                   (set/intersection area))]
      [:g (om/build-all hexagon-view
-                       (for [[j k] hits
+                       (for [[j k] area
                              :let [[x y] (coords-to-pixel [j k])]]
                          {:x x
                           :y y
                           :size TILE-SIZE
                           :label "D"
                           :position [j k]})
-                       {:key :position})])))
-
-(defn droid-shot [{:keys [sequence from]} owner]
+                       {:key :position})
+      [:g {:class "display"}
+       (for [hit hits
+             :let [[x y] (coords-to-pixel hit)]]
+         [:text {:class "damage"
+                 :x x :y y}
+          (str "-" dmg "HP")])]])))
+
+(defn droid-shot [{:keys [sequence from dmg]} owner]
   (reify
     om/IInitState
     (init-state [_]

(defmethod handle-message! "gamestate"
  [gamestate]
  (let [new-state (update-in gamestate [:players]
                             (partial map parse-position))]
    (reset! state new-state)
    (timeout 0)))


    "left-down"  [ 1  0]
    "right-down" [ 0  1]))

(defn length [[ax ay] [bx by]]
  (js/Math.sqrt
   (+ (js/Math.pow (- ax bx) 2)
      (js/Math.pow (- ay by) 2))))

(defn get-weapon [player weapon]
  (first
   (drop-while (comp (partial not= weapon) :name)
               (select-keys player
                            [:primary-weapon
                             :secondary-weapon]))))

(defmulti handle-action :type)

(defmethod handle-action "laser"
  [{:keys [from stop direction] :as action}]
  (let [player (player! from)
        level (:level (get-weapon player "laser"))]
    (swap! state assoc :action
           (assoc action
             :start (:position player)
             :stop (parse-coords stop)
             :dmg (+ 16 (* 2 (dec level)))))))

(defmethod handle-action "droid"
  [{:keys [sequence from] :as action}]
  (let [level (:level (get-weapon (player! from) "droid"))]
    (swap! state assoc :action
           (assoc action
             :sequence (mapv direction->coord
                             sequence)
             :dmg (+ 20 (* 2 level))))))

(defmethod handle-action "mortar"
  [{:keys [from coordinates :as action]}]
  (let [player (player! from)
        level (->> (select-keys player [:primary-weapon
                                        :secondary-weapon])
                   (drop-while (comp (partial not= "mortar") :name))
                   first
                   :level)]
    (swap! state assoc :action
           (assoc action
             :coord (mapv +
                          (:position player)
                          (parse-coords coordinates))
             :radius (inc level)
             :dmg (if (= 3 level) 25 20)))))

(defmethod handle-action "move"
  [{:keys [direction from]}]
