           (if (empty? sucessors)
             best
             (let [{child-best-move :best-move tmp-child-best-value :best-value who-win? :who-win?} (negamax-inner (first (first sucessors))
-                                                                                               (- beta)
-                                                                                               (- alpha)
-                                                                                               got-time?
-                                                                                               (not is-first-player)
-                                                                                               (dec max-depth)
-                                                                                               grid-width
-                                                                                               grid-height)
+                                                                                                                  (- beta)
+                                                                                                                  (- alpha)
+                                                                                                                  got-time?
+                                                                                                                  (not is-first-player)
+                                                                                                                  (dec max-depth)
+                                                                                                                  grid-width
+                                                                                                                  grid-height)
                   child-best-value (- tmp-child-best-value)]
 
               (if (and (= child-best-value (best :best-value) Double/POSITIVE_INFINITY)

                                           Double/POSITIVE_INFINITY
                                           got-time?
                                           (not is-first-player)
                                           deepness          ; Steps
                                           grid-width grid-height))

        (recur (inc deepness)))
      (prn "Deepness" deepness)
      )))

  (defn -getNextMove
    "Gets the next best move"
    [charmat timeout]
    (let [ret-chan (async/chan (async/sliding-buffer 1))
          timeout-chan (async/timeout timeout)
          got-time? (atom true)
          charmat-seq (lazy-seq charmat)
          state (gen-map-from-charmat charmat-seq {true #{} false #{}} 0)
          is-first-player (even? (+ (count (state true)) (count (state false))))
          grid-width (count (first charmat-seq))
          grid-height (count charmat-seq)]

      (async/go
        (negamax is-first-player
                 state
                 got-time?
                 grid-width
                 grid-height
                 ret-chan))

      ; Block on the timeout channel
      (async/<!! timeout-chan)

      (let [{decision :best-move} (async/<!! ret-chan)]
        (swap! got-time? (fn [lastval] false))
        (into [] decision))))
                                            :else (inc prev-left-partial-streak-count))

            right-partial-streak-count (cond (or right-is-dead (not= right :empty)) prev-right-partial-streak-count
                                             :else (inc prev-right-partial-streak-count)) ;

            left-direct-streak (if left-direct-streak-is-dead prev-left-direct-streak (inc prev-left-direct-streak))
            right-direct-streak (if right-direct-streak-is-dead prev-right-direct-streak (inc prev-right-direct-streak))
