             :else   (move-towards -10 c collision-area))))
 
 (defn rule-match-velocity [c cs]
-    (let [  other-critters  (exclude c cs)
-            avg-velocity    (average-velocity other-critters)
+    (let [  avg-velocity    (average-velocity cs)
             r               (:r avg-velocity)
-            velocity        (assoc avg-velocity :r (/ r 4))
+            velocity        (assoc avg-velocity :r (/ r 2))
             with-v          (assoc c :velocity velocity)
             diff            (polar->cartesian velocity)]
         (subtract-point with-v diff)))
 
+(defn rule-avoid-mouse [c mouse]
+    (let [ near-mouse?  (near-points? c mouse 100)]
+        (cond near-mouse? (move-towards -50 c mouse) :else c)))
+
 (defn critter-destination [c state]
-    (let [  cs  (:critters state)]
+    (let [  other-critters  (exclude c (:critters state))]
         (-> c
-            (rule-to-center cs)
+            (rule-to-center other-critters)
             (rule-avoid-walls (:width state) (:height state))
-            (rule-avoid-collisions cs)
-            (rule-match-velocity cs)
+            (rule-avoid-collisions other-critters)
+            (rule-match-velocity other-critters)
+            (rule-avoid-mouse (:mouse state))
             )))
 
 

            diff        (polar->cartesian velocity)]
        (subtract-point with-v diff)))

(defn critter-collision? [c1 c2]
    (let [  diff            (abs-point (subtract-point c1 c2))
            space           {:x 40 :y 40}
            {:keys [x y]}   (gt-point space diff)]
        (and (not= c1 c2) (and x y))))

(defn exclude [x xs] (filter #(not= % x) xs))

(defn rule-to-center [c cs]
    (let [  other-critters  (exclude c cs)
            other-center    (center-of-points other-critters)]
        (move-towards 5 c other-center)))

(defn rule-avoid-walls [c width height]
    (let [  {:keys [x y]}   c]

                :else c)))

(defn rule-avoid-collisions [c cs]
    (let [  collisions      (filter #(near-points? c % 20) cs)
            collision-area  (center-of-points collisions)
            no-collision?   (empty? collisions)]
        (cond   
