                                              decision-maker-coords
                                              (au/create-new-contents :open)))
         (cond->
-            is-player? (update-player-stats decision-maker-contents
-                                            desired-space-contents)))))
+            is-player (update-player-stats decision-maker-contents
+                                           desired-space-contents)
+            ;; If a wombat died moving (without colliding) it died from poison
+            wombat-died (update-in [:game/players
+                                    (:uuid decision-maker-contents)
+                                    :player/stats]
+                                   (fn [stats]
+                                     (-> stats
+                                         (update :stats/deaths inc)
+                                         (update :stats/deaths-by-poison inc))))))))
 
 (defn- apply-collision-damage
   [contents]


  (let [updated-desired-space (apply-collision-damage desired-space-contents)
        updated-decision-maker (apply-collision-damage decision-maker-contents)
        take-space? (can-safely-occupy-space? updated-desired-space)]
    (cond-> (update-collision-stats game-state
                                    desired-space-contents
                                    decision-maker-contents)
      take-space?
      (update-in [:game/frame :frame/arena]
                 #(au/update-cell-contents %
                                           desired-space-coords
                                           updated-decision-maker))
      take-space?
      (update-in [:game/frame :frame/arena]
                 #(au/update-cell-contents %
                                           decision-maker-coords
                                           (au/create-new-contents :open)))
      (not take-space?)
      (update-in [:game/frame :frame/arena]
                 #(au/update-cell-contents %
                                           desired-space-coords
                                           updated-desired-space))
      (not take-space?)
      (update-in [:game/frame :frame/arena]
                 #(au/update-cell-contents %
                                           decision-maker-coords

   {collision-type :type}
   {self-type :type
    self-uuid :uuid}]
  (update-in game-state [:game/players self-uuid :player/stats]
             (fn [stats]
               (case collision-type
                 :wombat (update stats :stats/wombat-collisions inc)
                 :zakano (update stats :stats/zakano-collisions inc)
                 :steel-barrier (update stats :stats/steel-barrier-collisions inc)
                 :wood-barrier (update stats :stats/wood-barrier-collisions inc)
                 stats))))

(defn- update-collision-death-stats
  [game-state
   {victim-type :type
    victim-uuid :uuid}
   {collision-type :type}]
  (update-in game-state [:game/players victim-uuid :player/stats]
             (fn [stats]
               (-> stats
                   (update :stats/deaths inc)
                   (update (case collision-type
                             :wombat :stats/deaths-by-wombat-collision
                             :zakano :stats/deaths-by-zakano-collision
                             :steel-barrier :stats/deaths-by-steel-barrier-collision
                             :wood-barrier :stats/deaths-by-wood-barrier-collision)
                           inc)))))

(defn- update-move-stats
  [game-state
   desired-space-contents
   updated-desired-space
   decision-maker-contents
   updated-decision-maker]

  (let [decision-maker-type (:type decision-maker-contents)
        updated-decision-maker-type (:type updated-decision-maker)
        desired-space-type (:type desired-space-contents)
        updated-desired-space-type (:type updated-desired-space)
        decision-maker-is-wombat (= :wombat decision-maker-type)
        desired-space-is-wombat (= :wombat desired-space-type)
        decision-maker-wombat-died (and decision-maker-is-wombat
                                        (not= updated-decision-maker-type :wombat))
        victim-wombat-died (and desired-space-is-wombat
                                (not= updated-desired-space-type :wombat))]
    (cond-> game-state
      ;; Update the decision makers collision stats
      decision-maker-is-wombat
      (update-collision-stats desired-space-contents
                              decision-maker-contents)

      ;; Update the reverse if wombat
      desired-space-is-wombat
      (update-collision-stats decision-maker-contents
                              desired-space-contents)

      ;; Update the decision makers death stats
      decision-maker-wombat-died
      (update-collision-death-stats decision-maker-contents
                                    desired-space-contents)

      ;; Update the victims death stats
      victim-wombat-died
      (update-collision-death-stats desired-space-contents
                                    decision-maker-contents))))

(defn- resolve-collision
  [game-state
