(defstruct aount :h1 :h2 :h3 :h4 :h5 :h6 :h7 :h8 ) 
(def rowi1 (struct aount "x " \space "x " \space "x "  \space "x "  \space  ))
(def rowi2 (struct aount \space "x " \space "x "  \space "x "  \space "x "))
(def rowi3 (struct aount "x " \space "x " \space "x "  \space "x "  \space  ))
(def rowi4 (struct aount  \space "x " \space "x "  \space "x "  \space "x " ))
(def rowi5 (struct aount \space \space \space \space \space \space \space \space ))
(def rowi6 (struct aount  \space \space \space \space \space \space \space \space ))
(def rowi7 (struct aount  "y " \space "y " \space "y " \space  "y " \space))
(def rowi8 (struct aount  \space "y " \space "y " \space "y " \space "y "))
(def rowi9 (struct aount "y " \space "y " \space "y " \space  "y " \space))
(def rowi10 (struct aount \space "y " \space "y " \space "y " \space "y "))
;;(def rowi8 (struct aount "x" "x" "x" "x"))

;;(def alist (list sande1  sande2  sande3 sande4 sande5 sande6 sande7 sande8 sande9 sande10))
;alist

(def sande1 (ref rowi1))
(def sande2 (ref rowi2))
(def sande3 (ref rowi3))
(def sande4 (ref rowi4))
(def sande5 (ref rowi5))
(def sande6 (ref rowi6))
(def sande7 (ref rowi7))
(def sande8 (ref rowi8))
(def sande9 (ref rowi9))
(def sande10 (ref rowi10))

(def *ban* 5)
(def *bin* 10)
(def *cnum* 0)

(defn dev-checker [san]
(do (println  "\n" \space (str (:h1 @san) \space (:h2 @san) \space (:h3 @san) \space (:h4 @san) \space (:h5 @san) \space (:h6 @san) \space (:h7 @san) \space (:h8 @san) \space ))))

(map dev-checker (list sande3 sande4 sande3))

(defn row-to-create []
 (apply vector  (map  dev-checker   (list sande1 sande2 sande3 sande4 sande5 sande6 sande7 sande8 sande9 sande10))))
 
 (defn check-cell-empty? [ key alon]
 (= (key @alon) \space))
 
 (defn with-in-range [m k]
 (and (>= (dec m) 0) (<= (inc m) k)))
 
 (defn is-cellpiece-same? [ key1 alon1 key2 alon2]
 (= (key1 @alon1) (key2 @alon2)))
 
 
 ; check that piece is within
 (defn check-range-piece? [pred fun i num]
  (pred (fun i ) num))
  
  ;checks that range is within (pred could be <= or >=) , could be inc or dec
  (defn check-range-row? [pred fun k cnum]
  (pred (fun k) cnum))
 
 
 (defn get-next-row [ f m]
 (symbol (str "sande" (f m))))
 
 (defn get-key [f m]
(keyword (str "h"(f m))))

(defn chang[f  key hj]
(dosync (ref-set f (assoc @f key hj))))
 
 (defn extract-num [sand key]
(let [n (Integer/parseInt (re-find #"\d+$" (name sand))) 
        m (Integer/parseInt (re-find #"\d+$" (name key)))]
        [n m]))
        
        
(defn proceed-now-left [alon key]
    (let [val (extract-num alon key)
         row-dev (eval (get-next-row inc (first val)))
         keyword-dev-left (get-key dec (second val))
         cell-empty-left (check-cell-empty? keyword-dev-left row-dev)]
         (if cell-empty-left
        (do (chang row-dev keyword-dev-left (@alon key)) (chang alon key \space))
        (println "can't do this"))))
         
  (defn proceed-now-right  [alon key]
    (let [val (extract-num alon key)
         row-dev (eval (get-next-row inc (first val)))
         keyword-dev-right (get-key inc  (second val))
         cell-empty-right (check-cell-empty? keyword-dev-right   row-dev)]
         (if cell-empty-right
         (do (chang row-dev keyword-dev-right (@alon key)) (chang alon key \space))
         (println "can't do this"))))
        
  (defn proceed-now [alon key-right key-left]
  (let [val (extract-num alon key-right)
        row-dev (eval (get-next-row inc (first val)))
        keyword-dev-right (get-key inc (second val))
        cell-empty-right (check-cell-empty? keyword-dev-right  row-dev)]
        (if cell-empty-right
         (do  (chang row-dev keyword-dev-right (@alon key-right)) (chang alon key-right \space))
        (proceed-now-left alon key-left))))
        
        
        
        
(defn move-piece [key alon]
(let [val (extract-num alon key)
      row-dev (eval (get-next-row inc (first val)))
      keyword-dev-right (get-key inc (second val))
      keyword-dev-left (get-key dec (second val))
      next-l-row-piece ( row-dev keyword-dev-left )
      next-r-row-piece (row-dev  keyword-dev-right)
      cell-empty-right  (check-cell-empty? keyword-dev-right row-dev)
      cell-empty-left  (check-cell-empty?  keyword-dev-left row-dev)
      state-of-piece-right  (if (next-r-row-piece) (is-cellpiece-same? keyword-dev-right row-dev key alon) "oop")
      state-of-piece-left   (if (next-l-row-piece) (is-cellpiece-same? keyword-dev-left row-dev key alon) "oop")
      ]
      (cond
      (and cell-empty-right cell-empty-left)
      (if (= 0 (rand-int 2) ) (chang row-dev keyword-dev-right (@alon key))
      (chang row-dev keyword-dev-left (@alon key)))
      (and cell-empty-right state-of-piece-left) (chang row-dev keyword-dev-right (@alon key))
      (and cell-empty-left state-of-piece-right) (chang row-dev keyword-dev-left (@alon key))
      (and state-of-piece-right state-of-piece-left)  (println "you can't move this piece")
      (and (not state-of-piece-right) (not state-of-piece-right)) (proceed-now row-dev  keyword-dev-right keyword-dev-left)
      (not state-of-piece-right) (proceed-now-right row-dev keyword-dev-right)
      (not state-of-piece-left) (proceed-now-left row-dev keyword-dev-left)
      :else (println "you can't move this piece"))))