    * 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))
     ))
 

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

(defn move-strength
  ;; TODO - Count taken is bad: select a better evaluation
  ;; TODO - It requires however to change the initial scoring as well
  "Compute the strength value of a move"
  [move]
  (count (:taken move)))

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

   * And with move scope limitation"
  [moves move-filter]
  (fast-max-key
    (partial move-strength move-filter)
    moves))

(defn worst-immediate-loss
