           (.sortable (js/$ "#placed") (clj->js {
                                                 :items "li:not(.ui-state-disabled)"
                                                 :connectWith ".connectedSortable"
-                                                :update (fn [e ui] (re-sort (-> e .-target .-childNodes)))
+                                                :update (fn [e ui] (update-voted-out (-> e .-target .-childNodes)))
                                                 }))
           (.disableSelection (js/$ "#placed")))))
 

                        {:id 18 :name "Will" :out 0 :tribe "nagarote"}
                        ]))

(def entries (atom [
                    {:id 1 :name "phil" :points 0 :order [18 17 16 15 14 13 12 11 1 10 9 8 7 6 5 4 3 2]}
                    {:id 2 :name "will" :points 0 :order [2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 1]}
                    {:id 3 :name "ciwchris" :points 0 :order [4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 1 2 3]}
                    {:id 11 :name "last" :points 0 :order [3 1 2 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18]}
                    ]))

(def selected-entry (atom 1))

;; -------------------------
;; To read the players when sorted

                         [:img {:src (str "/images/" (:name item) ".png")}]
                         [:div (:name item)]])])

(defn create-contestant-list [entries selected-entry voted-out-list]
  (let [entry-contestant-order (:order (first (filter #(= selected-entry (:id %)) entries)))]
            (map
             #(first (filter (fn [voted-out-entry] (= (:id voted-out-entry) %)) voted-out-list))
             entry-contestant-order)))

(defn calculate-points-for-entry
  ([entry] (calculate-points-for-entry 0 18 entry))
  ([points max-points entry]
   (if (empty? entry)
     points
     (let [new-points (if (nil? (first entry))
                        0
                        (Math/abs (- max-points (:out (first entry)))))]
       (recur
