       (let [[obj1 coll2] (check-collision (first coll1) coll2)]
         (recur (rest coll1) coll2 (conj coll1-result obj1))))))
 
-(defmulti handle-collision (fn [{type :type}]
+(defmulti handle-damage (fn [{type :type}]
                              (if (#{:ship :shot :asteroid} type)
                                type
                                :other)))
 
-(defmethod handle-collision :ship [{:keys [hit? life] :as ship}]
-  (when hit? (play-sound (if (<= (dec life) 0) "ship-destroyed" "ship-hit")))
-  (if hit?
-    (assoc ship :life (dec life)
-                :hit? false)
+(defmethod handle-damage :ship [{:keys [damage-taken life] :as ship}]
+  (when damage-taken (play-sound (if (<= life damage-taken) "ship-destroyed" "ship-hit")))
+  (if damage-taken
+    (assoc ship :life (- life damage-taken)
+                :damage-taken nil)
     ship))
 
-(defmethod handle-collision :shot [{:keys [hit?] :as shot}]
-  (when hit? (play-sound "asteroid-hit"))
-  (if hit?
+(defmethod handle-damage :shot [{:keys [damage-taken] :as shot}]
+  (when damage-taken (play-sound "asteroid-hit"))
+  (if damage-taken
     nil
     shot))
 
-(defmethod handle-collision :missile [{:keys [hit?] :as missile}]
-  (when hit? (play-sound "asteroid-hit"))
-  (if hit?
+(defmethod handle-damage :missile [{:keys [damage-taken] :as missile}]
+  (when damage-taken (play-sound "asteroid-hit"))
+  (if damage-taken
     nil
     missile))
 
-(defmethod handle-collision :asteroid [{:keys [hit? crit-hit? size position speed] :as asteroid}]
-  (cond
-    crit-hit? (create-asteroids crit-fragment-number (/ size crit-fragment-size-reduction) position speed)
-    hit? (create-asteroids fragment-number (/ size fragment-size-reduction) position speed)
-    :else asteroid))
-
-(defmethod handle-collision :other [{hit? :hit? :as object}]
-  (if hit?
+(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))
 
 (defn resolve-all-collision [{shots :shots :as ship} asteroids]
   (let [[ship asteroids] (check-collision ship asteroids)
         [shots asteroids] (check-collision shots asteroids)
-        ship (handle-collision ship)
+        ship (handle-damage ship)
         shots (->> shots
-                   (map handle-collision)
+                   (map handle-damage)
                    flatten
                    (filter (comp not nil?)))
         asteroids (->> asteroids
-                       (map handle-collision)
+                       (map handle-damage)
                        flatten
                        (filter (comp not nil?)))]
     [(assoc ship :shots shots) asteroids]))

        square #(* % %)]
    (<= (+ (square delta-x) (square delta-y)) (square size))))

(defmulti check-collision
          (fn [obj1 obj2]
            (cond

              (and (sequential? obj1) (sequential? obj2)) :seq-seq)))

(defmethod check-collision :map-map [obj1 obj2]
  (if (and (:collidable? obj1)
           (:collidable? obj2)
           (collide? obj1 obj2))
    [(damage obj1 (:collidable? obj2)) (damage obj2 (:collidable? obj1))]
    [obj1 obj2]))

(defmethod check-collision :map-seq [obj1 coll]
  (loop [obj1 obj1, coll coll, coll-result []]
