           (gen-heuristic-dictionary width-heuristic-calculation)
           (apply clojure.math.combinatorics/cartesian-product
                  (for [_ (range width-heuristic-calculation)] [:min :max :wall :empty]))))
+
+(defn generate-valid-keys
+  ""
+  [depth]
+  (let [half-keys (filter
+                    #(loop [keys %
+                            wall-done false]
+                      (if (empty? keys)
+                        true
+                        (if (and (not wall-done) (not (= (first keys) :wall)))
+                          (recur (rest keys) true)
+                          (if (and wall-done (= (first keys) :wall))
+                            false
+                            (recur (rest keys) wall-done)))))
+                    (combo/selections [:min :max :empty :wall] (/ depth 2)))]
+    (for [k1 half-keys k2 half-keys] (concat k1 (reverse k2)))))
 
 (def heuristic-dict (fill-heuristics-dict))
 

  [list-to-check player opponent]

  (if
      (and
        (= (.indexOf list-to-check opponent) -1)
        (= (.indexOf list-to-check :wall) -1))
    (let [count-in-list (reduce #(+ %1 (if (= %2 player) 1 0)) 0 list-to-check)]
      (if (< count-in-list 3)
        (Math/pow 2 count-in-list)

                         [grid-w grid-h])))


(defn generate-world-from-position
  ""
  [grid-w grid-h state position is-first-player]
  (let [tstate (transient state)]
    (assoc! tstate is-first-player (conj (state is-first-player) position))
    (assoc! tstate :last-move position)
    (assoc! tstate :heuristic-result (get-value-for-state grid-w
