   (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)))
+  "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:

  (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:

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

