 
 (defn- available-cells-by-dir
   "Indicates the convertible cells when clicking at [x y]"
-  [board [x-init y-init :as init-coord] [dx dy]]
+  [board [x-init y-init :as destination] [dx dy]]
   (loop [x (+ x-init dx)
          y (+ y-init dy)
          looser nil
          taken []]
     (let [cell (aboard-cell-at board x y)]
       (cond
-        (is-not-convertible? cell) nil                      ;; No move: reached end and only 1 type of cell
-        (and looser (not= looser cell)) {:winner cell       ;; Who wins the cells
-                                         :looser looser     ;; Who looses the cells
-                                         :point init-coord  ;; The move performed
-                                         :taken taken}      ;; The cells taken
+        (is-not-convertible? cell) nil                            ;; No move: reached end and only 1 type of cell
+        (and looser (not= looser cell)) {:winner cell             ;; Who wins the cells
+                                         :looser looser           ;; Who looses the cells
+                                         :destination destination ;; The move performed
+                                         :taken taken}            ;; The cells taken
         :else (recur
                 (+ x dx)
                 (+ y dy)

  [board]
  (let [aboard (board/board->array board)]
    (map-transition-tree
      conversions->transition
      (transduce
        (mapcat #(available-conversions-at aboard %))
        (algo/group-by-reducer :winner :point)
        (board/empty-cells board)))))

(defn apply-transition
  [board transition]
  (reduce apply-conversion board transition))

;; -----------------------------------------
;; TESTS

                (conj taken [x y])))
      )))

(defn- available-jumps-at
  "Provides the list of moves that can be done from a cell"
  [board point]
  (eduction
