    * The immediate gain
    * The worse immediate lost afterwards"
   {:pre [(player? player)]}
-  [game player]
+  [cells-strength 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 (:cells-strength game) identity move)
-                losses (map #(worst-immediate-loss new-game % player) others)]
+                diff-score (move-strength cells-strength identity move)
+                losses (map #(worst-immediate-loss cells-strength new-game % player) others)]
             (- diff-score (apply max losses))))
         moves))
     ))

  "Manage transitions between player moves, ai moves, and generic game events"
  []
  (let [game-on-xf (fn [_] (not @end-of-game))
        is-human-xf (fn [_] (is-human? @current-player))
        is-ai-xf (fn [_] (not (is-human? @current-player)))
        ai-events (chan 1 (comp (filter game-on-xf) (filter is-ai-xf)))
        player-events (chan 1 (comp (filter game-on-xf) (filter is-human-xf)))
        game-events (chan 1)]

(defn- worst-immediate-loss
  "Return the next worse lost game move for 'looser' if 'player' plays"
  {:pre [(player? player) (player? looser)]}
  [cells-strength game player looser]
  (let [converted-filter #(= looser (:looser %))
        all-moves (get-in game [:moves player])]
    (transduce
      (map #(move-strength cells-strength converted-filter %))
      max all-moves)))

(defn best-move
