Clojurescript "Playable" Rubiks for your REPL

(ns rubiks.compudharma
  (:require
        [goog.string :as gstring]
            [goog.string.format]))

(use '[clojure.string :only (join split)])

(defn transpose [m]
  (apply mapv vector m))

(defn xmirror [m]
  (map reverse m))

(def rotl (comp transpose xmirror))
(def rotr (comp rotl rotl rotl))


(defn print-face [face]
  (doseq [i (range 0 (count face))] (println (get face i))))

(defn print-cube [cube]
  (doseq [i (range 0 (count cube))] (do (print-face (get cube i)) (println "-------"))))

(defn init-face [a n]
  (loop [row [] i n]
    (if (= i 0)
      row
      (recur (conj row (vec (replicate n a))) (dec i)))))

(defn num-face [n]
  (loop [row [] i 1]
    (if (= i (inc n))
      row
      (recur (conj row (vec (range (* (dec i) n) (* i n)))) (inc i)))))

(defn row-subst [face idx row]
  (assoc face idx row))

(defn col-subst [face idx col]
  (transpose (assoc (transpose face) idx col)))

(defn ninit-cube [n init]
  (loop [cube [] i 0]
    (if (= i 6)
      cube
      (recur (conj cube (init-face init n)) (inc i)))))

(defn init-cube [n]
  (loop [cube [] i 0]
    (if (= i 6)
      cube
      (recur (conj cube (init-face i n)) (inc i)))))

(defn rotxy-cube [cube]
 [(rotl (get cube 4)) (rotl (get cube 1)) (rotl (get cube 0)) (rotr (get cube 3)) (rotl (get cube 5)) (rotl (get cube 2))])

(defn rotyz-cube [cube]
 [(rotl (rotl (get cube 3))) (get cube 0) (rotr (get cube 2)) (rotl (rotl (get cube 5))) (rotl (get cube 4)) (get cube 1)])

(def nrotxy-cube (comp rotxy-cube rotxy-cube rotxy-cube))
(def nrotyz-cube (comp rotyz-cube rotyz-cube rotyz-cube))


(defn facerot-u [cube]
  (loop [ret [(rotr (get cube 0))] row (get (get cube 4) 0) i 1]
    (if (= i 5)
      (vec (concat ret [(get cube i)]))
      (recur (concat ret [(row-subst (get cube i) 0 row)]) (get (get cube i) 0) (inc i)))))

(defn facerot-ui [cube]
  (loop [ret [] row (get (get cube 1) 0) i 4]
    (if (= i 0)
      (vec (concat [(rotl (get cube 0))] ret [(get cube 5)]))
      (recur (concat [(row-subst (get cube i) 0 row)] ret) (get (get cube i) 0) (dec i)))))

(defn facerot-f [cube]
  ((comp rotyz-cube facerot-u nrotyz-cube) cube))

(defn facerot-fi [cube]
  ((comp rotyz-cube facerot-ui nrotyz-cube) cube))

(defn facerot-r [cube]
  ((comp nrotxy-cube facerot-u rotxy-cube) cube))

(defn facerot-ri [cube]
  ((comp nrotxy-cube facerot-ui rotxy-cube) cube))

(defn facerot-l [cube]
  ((comp rotxy-cube facerot-u nrotxy-cube) cube))

(defn facerot-li [cube]
  ((comp rotxy-cube facerot-ui nrotxy-cube) cube))

(defn facerot-b [cube]
  ((comp nrotyz-cube facerot-u rotyz-cube) cube))

(defn facerot-bi [cube]
  ((comp nrotyz-cube facerot-ui rotyz-cube) cube))

(defn facerot-d [cube]
  ((comp nrotyz-cube nrotyz-cube facerot-u rotyz-cube rotyz-cube) cube))

(defn facerot-di [cube]
  ((comp nrotyz-cube nrotyz-cube facerot-ui rotyz-cube rotyz-cube) cube))


(defn facerot-str [cube rot]
  (case rot
    "u"   (facerot-u cube)
    "ui"  (facerot-ui cube)
    "f"   (facerot-f cube)
    "fi"  (facerot-fi cube)
    "l"   (facerot-l cube)
    "li"  (facerot-li cube)
    "b"   (facerot-b cube)
    "bi"  (facerot-bi cube)
    "r"   (facerot-r cube)
    "ri" (facerot-ri cube)
    "d" (facerot-d cube)
    "di" (facerot-di cube)))


(defn facerot-idx [cube rotidx]
  (case rotidx
    0 (facerot-u cube)
    1 (facerot-ui cube)
    2 (facerot-f cube)
    3 (facerot-fi cube)
    4 (facerot-l cube)
    5 (facerot-li cube)
    6 (facerot-b cube)
    7 (facerot-bi cube)
    8 (facerot-r cube)
    9 (facerot-ri cube)
    10 (facerot-d cube)
    11 (facerot-di cube)))

(defn facerot-batch [cube rotbatch]
  (loop [rots (split rotbatch #",") c cube]
    (if (= 0 (count rots))
      c
      (recur (subvec rots 1) (facerot-str c (first rots))))))

(defn randomize-cube [cube n]
  (loop [c cube i n]
    (if (= i 0)
      c
      (recur (facerot-idx c (rand-int 12)) (dec i)))))

(defn solved-cube [cube n]
  (= cube (init-cube n)))