    * The worse immediate lost afterwards"
   [game player]
   (let [moves (get-in game [:moves player])
-        others (remove #{player} players)
-        score (get-in game [:scores player])]
+        others (remove #{player} players)]
     (first
       (fast-max-key
-        (fn [[m converted]]
+        (fn [[m converted :as move]]
           (let [new-game (play-move game m)
-                new-score (get-in new-game [:scores player]) ;; TODO - Use score heuristic here
+                diff-score (move-strength identity move)
                 losses (map #(worst-immediate-loss new-game % player) others)]
-            (- new-score (apply max losses))))
+            (- diff-score (apply max losses))))
         moves))
     ))
 

  (let [move-filter #(= looser (:looser %))
        all-moves (get-in game [:moves player])
        move (best-immediate-move-with all-moves move-filter)]
    (transduce (map (comp count :taken)) + (second move))
    ))

(defn best-move
  "[SIMPLISTIC] Return the best move for a player based on:

  (apply max-key (memoize key-fn) coll))

(defn move-strength
  "Compute the strength of a move, based on the converted cells"
  [move-filter [move converted]]
  (transduce
    (comp
      (filter move-filter)
      (map (comp count :taken)))
    + converted))

(defn- best-immediate-move-with
  "Return the move with the highest immediate score increase:
