ttt with a cli

practice/ttt/README.md

@@ -0,0 +1,46 @@
+# Tic Tac Toe 
+### Cli interface 
+
+To start the game use `lein run`
+
+Possible positions:
+
+| 1   | 2   | 3   |
+|-----|-----|-----|
+ | 4   | 5   | 6   |
+| 7   | 8   | 9   | 
+
+=> lein run: 
+
+Enter a number between 1-9 to make a move
+
+Enter h to view position board
+
+Enter q to quit
+
+Current board:
+
+| e   | e   | e   |
+|-----|-----|-----|
+| e   | e   | e   |
+| e   | e   | e   |
+
+Player is o
+=> 1 
+
+Current board:
+
+| o   | e   | e   |
+|-----|-----|-----|
+| e   | e   | e   |
+| e   | e   | e   | 
+
+Player is x
+
+=> q
+
+Bye bye!
+
+### Developer notes
+
+Run tests using `lein test`

practice/ttt/board.clj

@@ -0,0 +1,84 @@
+(ns ttt.board
+  (:refer-clojure :exclude [update])
+  (:require
+    [clojure.set]
+    [ttt.matrix-operations :as mo]))
+
+
+(def size 3)
+
+
+(def position-to-coordinate
+  (->> (for [x (range size)
+             y (range size)]
+         [x y])
+       (map-indexed (fn [i coord] [(inc i) coord]))
+       (into {})))
+
+
+(def empty-board
+  (mapv vec (partition size (repeat (* size size) :e))))
+
+
+(def valid-positions
+  (keys position-to-coordinate))
+
+
+(def positions-string
+  (mo/matrix->string (partition size (sort valid-positions))))
+
+
+(def valid-game-pieces-set #{:o :x :e})
+
+(def game-pieces-set #{:o :x})
+
+
+(defn to-string
+  [board]
+  (mo/matrix->string (mapv #(mapv name %) board)))
+
+
+(defn empty-coordinate?
+  [board coordinate]
+  (= :e (get-in board coordinate)))
+
+
+(defn valid?
+  [board]
+  (and (mo/square-matrix? board)
+       (clojure.set/subset? (set (flatten board)) valid-game-pieces-set)))
+
+
+(defn update
+  [board coordinate game-piece]
+  (when (valid? board)
+    (assoc-in board coordinate game-piece)))
+
+
+(defn winner-of-collection
+  [coll]
+  (let [unique-val (set coll)]
+    (when (and
+            (= 1 (count unique-val))
+            (not (:e unique-val)))
+      (first unique-val))))
+
+
+(defn winners-of-seqs
+  [matrix]
+  (->> matrix
+       (mo/get-all-possible-seqs)
+       (map winner-of-collection)
+       (remove nil?)))
+
+
+(defn winning-game-piece
+  [board]
+  (when (= 1 (count (winners-of-seqs board)))
+    (first (winners-of-seqs board))))
+
+
+(defn winner
+  [board]
+  (when (valid? board)
+    (winning-game-piece board)))

practice/ttt/core.clj

@@ -0,0 +1,8 @@
+(ns ttt.core
+  (:gen-class)
+  (:require [ttt.game :as game]
+            [ttt.board :as board]))
+
+(defn -main
+  []
+  (game/play board/empty-board))

practice/ttt/game.clj

@@ -0,0 +1,63 @@
+(ns ttt.game
+  (:require
+    [failjure.core :as f]
+    [ttt.board :as board]
+    [ttt.user-input :as user-input]))
+
+
+(def player-order
+  (take 9 (cycle board/game-pieces-set)))
+
+
+(defn over?
+  [board player-sequence]
+  (or (board/winner board)
+      (empty? player-sequence)))
+
+
+(defn process-parsed-command
+  [parsed-command board player-sequence]
+  (case parsed-command
+    "h" (do
+          (println "\nPosition board" board/positions-string "\n")
+          [board player-sequence])
+
+    "q" [nil player-sequence]
+
+    (let [player (first player-sequence)]
+      (if (board/empty-coordinate? board parsed-command)
+        [(board/update board parsed-command player) (rest player-sequence)]
+        (do (println "Enter an empty position")
+            [board player-sequence])))))
+
+
+(defn process-command
+  [command board player-sequence]
+  (f/attempt-all [valid-command (user-input/valid-command? command)
+                  parsed-command (user-input/parse-command valid-command)]
+                 (process-parsed-command parsed-command board player-sequence)
+                 (f/when-failed [e]
+                                (println (f/message e))
+                                [board player-sequence])))
+
+
+(defn play
+  [board]
+  (println "Enter a number between 1-9 to make a move \nEnter h to view position board \nEnter q to quit")
+  (loop [board           board
+         player-sequence player-order]
+    (cond
+      (or (nil? board))
+      (println "Bye bye!")
+
+      (over? board player-sequence)
+      (if-let [winner (board/winner board)]
+        (println "Winner is" (name winner))
+        (println "It's a draw"))
+
+      :else
+      (do (println "Current board:" (board/to-string board)
+                   "\nPlayer is" (name (first player-sequence)))
+          (let [command (read-line)
+                [new-board new-player-sequence] (process-command command board player-sequence)]
+            (recur new-board new-player-sequence))))))

practice/ttt/matrix_operations.clj

@@ -47,3 +47,11 @@
     (transpose-matrix matrix)
     (get-diagonals-of-matrix matrix)))
 
+
+(defn matrix->string
+  [matrix]
+  (apply str (for [row matrix]
+               (str
+                 (apply str "\n"
+                        (interpose " " row))))))
+

practice/ttt/test/board_test.clj

@@ -0,0 +1,76 @@
+(ns board-test
+  (:require
+    [clojure.test :refer :all]
+    [ttt.board :refer :all]))
+
+
+(def test-empty-board
+  [[:e :e :e]
+   [:e :e :e]
+   [:e :e :e]])
+
+
+(deftest empty-coordinate-test
+  (testing "Returns true"
+    (testing "when position is empty"
+      (is (= true (empty-coordinate? test-empty-board [1 1])))))
+  (testing "Returns false"
+    (testing "when position is not empty"
+      (is (= false (empty-coordinate? [[:e :e :e]
+                                       [:e :o :e]
+                                       [:e :e :e]] [1 1]))))))
+
+
+(deftest valid-test
+  (testing "Returns true"
+    (testing "when board is a square matrix and all pieces are valid"
+      (is (= true (valid? test-empty-board)))))
+  (testing "Return false"
+    (testing "when board is not square matrix and all pieces are valid"
+      (is (=  false (valid? [[:e :e :e]]))))
+    (testing "when board is square matrix and all pieces are not valid"
+      (is (=  false (valid? [[:e :e :e]
+                             [:e :e :e]
+                             [:e :e 1]]))))))
+
+
+(deftest update-test
+  (testing "Returns correctly updated board"
+    (testing "when board is valid"
+      (is (= [[:e :e :e]
+              [:e :o :e]
+              [:e :e :e]] (update test-empty-board [1 1] :o))))))
+
+
+(deftest winner-of-collection-test
+  (testing "With all :e elements"
+    (is (= nil (winner-of-collection [:e :e :e]))))
+
+  (testing "With all :x elements "
+    (is (= :x (winner-of-collection [:x :x :x]))))
+
+  (testing "With 2 :x elements"
+    (is (= nil (winner-of-collection [:x :x :o])))))
+
+
+(deftest winning-game-piece-test
+
+  (testing "Returns winning game piece "
+    (testing "when winner is along a row"
+      (is  (= :o (winning-game-piece [[:e :x :e]
+                                      [:o :o :o]
+                                      [:x :e :x]]))))
+    (testing "when winner is along column"
+      (is (= :x (winning-game-piece [[:x :e :o]
+                                     [:x :e :e]
+                                     [:x :e :o]]))))
+    (testing "when winner is across diagonal"
+      (is (= :x (winning-game-piece [[:x :e :e]
+                                     [:o :x :e]
+                                     [:o :e :x]])))))
+
+  (testing "Returns nil "
+    (testing "when there is a draw"
+      (is (= nil (winning-game-piece [[:x :e :o]
+                                      [:x :x :e]
+                                      [:o :x :o]]))))))

practice/ttt/test/game_test.clj

@@ -0,0 +1,30 @@
+(ns game-test
+  (:require
+    [clojure.set]
+    [clojure.test :refer :all]
+    [ttt.game :refer :all]))
+
+
+(def test-player-sequence (cycle #{:o :x}))
+
+
+(deftest over-test
+  (testing "Returns winner "
+    (testing "when there is a winner in board"
+      (is (= :o (over? [[:e :x :e]
+                        [:o :o :o]
+                        [:x :e :x]] (take 2 test-player-sequence))))))
+  (testing "Returns true"
+    (testing "when there is a draw"
+      (is (= true (over? [[:x :o :x]
+                          [:x :o :o]
+                          [:o :x :x]] (take 0 test-player-sequence))))))
+  (testing "Returns false"
+    (testing "when there no winner with moves left"
+      (is (= false (over? [[:x :e :o]
+                           [:e :x :e]
+                           [:o :x :o]] (take 3 test-player-sequence)))))
+    (testing "when the board is empty"
+      (is (= false (over? [[:e :e :e]
+                           [:e :e :e]
+                           [:e :e :e]] (take 9 test-player-sequence)))))))

practice/ttt/test/matrix_operations_test.clj

@@ -20,10 +20,8 @@
             [2 5 8]
             [3 6 9]]
            (transpose-matrix test-square-matrix))))
-  (testing "With 2x1 matrix"
-    (is (= [[0 2]] (transpose-matrix [[0] [2]]))))
-  (testing "With empty matrix"
-    (is (= [[]] (transpose-matrix [[]])))))
+  (testing "With 1x2 matrix"
+    (is (= [[0 2]] (transpose-matrix [[0] [2]])))))
 
 
 (deftest primary-diag-coordinates-test
@@ -58,3 +56,9 @@
   (testing "With 1x2 matrix"
     (is (= false (square-matrix? test-1-by-2-matrix)))))
 
+
+(deftest matrix-to-string-test
+  (testing "With 3x3 matrix"
+    (is (= "\n1 2 3\n4 5 6\n7 8 9" (matrix->string test-square-matrix))))
+  (testing "With 1x2 matrix"
+    (is (= "\n1 2" (matrix->string test-1-by-2-matrix)))))