adding tictactoe game

Author: roppa

README.md

@@ -95,6 +95,8 @@ println!("{}, {}, {}", a.0, a.1, a.2);
 
 Arrays are limited to 32 length. Vectors are preferred over Arrays.
 
+To inspect an array use `println!("{:?}", arr);`.
+
 ## Variables
 
 Variables are immutable in Rust, however, you can mutate them by declaring using `let mut`. Rust is strongly typed, but if it can deduce what the variable is, it will automatically create that type for you.
@@ -195,6 +197,13 @@ https://crates.io/
 
 ## Ownership and References
 
+## Command line
+
+```rust
+let args: Vec<String> = std::env::args().skip(1).collect();
+println!("{:?}", args);
+```
+
 ## Resources
 
 - [Actix api framework](https://actix.rs)

tictactoe/.gitignore

@@ -0,0 +1,2 @@
+/target
+**/*.rs.bk

tictactoe/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "tictactoe"
+version = "0.1.0"
+authors = ["Mark Robson <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

tictactoe/src/lib.rs

@@ -0,0 +1,66 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_matrix_should_return_false () {
+      let matrix: [String; 9] = Default::default();
+      assert_eq!(check_results(&matrix), false);
+    }
+
+    #[test]
+    fn row_matrix_should_return_true () {
+      let mut matrix: [String; 9] = Default::default();
+      matrix[0 as usize] = "x".to_string();
+      matrix[1 as usize] = "x".to_string();
+      matrix[2 as usize] = "x".to_string();
+      assert_eq!(check_results(&matrix), true);
+    }
+
+    #[test]
+    fn column_matrix_should_return_true () {
+      let mut matrix: [String; 9] = Default::default();
+      matrix[0 as usize] = "x".to_string();
+      matrix[3 as usize] = "x".to_string();
+      matrix[6 as usize] = "x".to_string();
+      assert_eq!(check_results(&matrix), true);
+    }
+
+    #[test]
+    fn draw_matrix_should_return_true () {
+      let matrix: [String; 9] = [
+        "x".to_string(), "o".to_string(), "x".to_string(),
+        "o".to_string(), "x".to_string(), "o".to_string(), 
+        "x".to_string(), "x".to_string(), "o".to_string()
+      ];
+      assert_eq!(check_results(&matrix), true);
+    }
+}
+
+const WINNING_SEQUENCES: [[i8; 3]; 8] = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]];
+
+pub fn check_results (matrix: &[String; 9]) -> bool {
+  let mut game_over = false;
+  for sequence in WINNING_SEQUENCES.iter() {
+    if (
+        !matrix[sequence[0] as usize].is_empty() &&
+        !matrix[sequence[1] as usize].is_empty() &&
+        !matrix[sequence[2] as usize].is_empty()
+      ) &&
+      (
+        matrix[sequence[0] as usize] == matrix[sequence[1] as usize] &&
+        matrix[sequence[1] as usize] == matrix[sequence[2] as usize]) {
+      println!("Player {} wins!", matrix[sequence[0] as usize]);
+      game_over = true;
+    } else {
+      let default = matrix.iter().position(|r| r.is_empty());
+      if !default.is_some() {
+        println!("Its a draw!");
+        game_over = true;
+      } else {
+        game_over = game_over || false;
+      }
+    }
+  }
+  return game_over;
+}

tictactoe/src/main.rs

@@ -0,0 +1,56 @@
+/**
+ * Tic Tac Toe or Naughts and crosses
+ * 
+ * Two players take turns with adding their moniker on a 3x3 grid with the aim of having a winning swequence:
+ * 
+ * Winning sequences are:
+ * - first line horizontal
+ * - second line horizontal
+ * - third line horizontal
+ * - first line vertical
+ * - second line vertical
+ * - third line vertical
+ * - diagonal l - r
+ * - diagonal r - l
+ **/
+
+use tictactoe::check_results;
+use std::io;
+use std::io::prelude::*;
+
+fn main() {
+    let stdin = io::stdin();
+    let lookup = ["a1",  "b1",  "c1", "a2",  "b2",  "c2", "a3",  "b3",  "c3"];
+    let players = ["x", "o"];
+    let mut current_player = 0;
+    let mut matrix: [String; 9] = Default::default();
+
+    println!("Tic-tac-toe");
+    println!("Ready player {}? Enter target square:", players[current_player].to_string());
+    println!("|----|----|----|");
+    println!("| a1 | b1 | c1 |");
+    println!("|____|____|____|");
+    println!("| a2 | b2 | c3 |");
+    println!("|____|____|____|");
+    println!("| a3 | b3 | c3 |");
+    println!("|____|____|____|");
+
+    for line in stdin.lock().lines() {
+        let input = line.unwrap();
+        let index = lookup.iter().position(|&r| r == input);
+        if index.is_some() {
+            if matrix[index.unwrap()].to_string() != "" {
+                println!("Already taken");
+                continue;
+            }
+            matrix[index.unwrap()] = players[current_player].to_string();
+            current_player = if current_player == 0 { 1 } else { 0 };
+            if check_results(&matrix) {
+                std::process::exit(1);
+            }
+            println!("Player {}, your go", players[current_player].to_string());
+        } else {
+           println!("Oops! Invalid square");
+        }
+    }
+}