                 :damage-taken nil)
     ship))
 
-(defmethod handle-damage :projectile [{:keys [damage-taken] :as projectile}]
-  (when damage-taken (play-sound "projectile-hit"))
+(defmethod handle-damage :shot [{:keys [type damage-taken position] :as shot}]
+  (when damage-taken (play-sound (str (name type) "-hit")))
   (if damage-taken
-    nil
-    projectile))
-
-(defmethod handle-damage :missile [{:keys [damage-taken] :as missile}]
-  (when damage-taken (play-sound "missile-hit"))
-  (if damage-taken
-    nil
-    missile))
+    (create-explosion position (-> ammunition-types type :explosion))
+    shot))
 
 (defmethod handle-damage :asteroid [{:keys [damage-taken size position speed] :as asteroid}]
   (if damage-taken
     (create-asteroids damage-taken (/ size (sqrt damage-taken)) position speed)
     asteroid))
 
-(defmethod handle-damage :other [{damage-taken :damage-taken :as object}]
-  (if damage-taken
-    nil
-    object))
+(defmethod handle-damage :other [object]
+  object)
 
 (defn resolve-all-collision [{shots :shots :as ship} asteroids]
   (let [[ship asteroids] (check-collision ship asteroids)

   :collidable?    false                                    ; is set to ship-damage at first movement / shooting
   })

(defn create-circle
  ([pos speed]
   {:type           :projectile

    :size           (* 0.5 ship-size)
    :shape          [[-1 -1] [1 1]]

    :color          (Color. 10 200 220)
    :paint-method   fill-circle

    :position       pos
    :speed          speed
    :acceleration   0

    :direction      0
    :rotation-speed 0

    :collidable?    'whatever
    }))

(defn create-shot [ammunition-type {:keys [position size direction speed] :as ship}]
  (let [dir-vec (m/rotate-vec direction [0 1])
        position (m/vec+vec position (m/num*vec size dir-vec))

          life-time (- life-time turn-millis)]
      (assoc debris :size size
                    :life-time life-time))))

(defmethod move :explosion [{:keys [life-time size color] :as explosion}]
  (if (< life-time turn-millis)
    nil
    (let [explosion (basic-move explosion)
          size (* size (- 1 (/ turn-millis life-time)))
          alpha (int (* (.getAlpha color) (- 1 (/ turn-millis life-time))))
          color (Color. (.getRed color) (.getGreen color) (.getBlue color) alpha)
          life-time (- life-time turn-millis)]
      (assoc explosion :size size
                       :life-time life-time
                       :color color))))

(defn move-many [coll]
  (->> coll
