tictactoe.rs

use std::io::{self, BufRead};

fn to_mark(i: u8) -> String {
    match i {
        1 => "X".to_string(),
        2 => "O".to_string(),
        _ => "-".to_string(),
    }
}

fn main() {
    let mut state = [[0u8; 3]; 3];

    let mut turn = 1u8;

    // https://doc.rust-lang.org/rust-by-example/flow_control/loop/nested.html
    'outer: loop {
        println!();
        println!("Okay, {} a number 1 - 9: ", to_mark(turn));

        // READ INPUT
        // https://stackoverflow.com/a/30186553
        let stdin = io::stdin();
        let line1 = stdin.lock().lines().next().unwrap().unwrap();

        // PARSE INPUT
        // https://stackoverflow.com/a/27683271
        let num = line1.to_string().parse::<u8>();
        let num = match num {
            Ok(num) => num,
            Err(_error) => {
                println!("Invalid input please try again");
                continue;
            }
        };

        if num < 1 || num > 9 {
            println!("Invalid input please try again");
            continue;
        }

        // MARK CELL
        // https://stackoverflow.com/a/53930630
        let mut i = 0;
        for row in state.iter_mut() {
            for cell in row.iter_mut() {
                i += 1;
                if i == num {
                    if *cell != 0u8 {
                        println!("Cell's full, please try again");
                        continue 'outer;
                    }
                    *cell = turn;
                }
            }
        }

        // PRINT BOARD
        println!("----------");
        for row in state.iter() {
            for (col_index, cell) in row.iter().enumerate() {
                print!("{}", to_mark(*cell));
                if col_index == 2 {
                    println!();
                } else {
                    print!(" | ");
                }
            }
        }
        println!("----------");

        // CHECK WINNER
        let mut winner = 0u8;
        for (i, row) in state.iter().enumerate() {
            if row[0] != 0u8 && row[0] == row[1] && row[1] == row[2] {
                winner = row[0];
                break;
            }

            if state[1][i] != 0u8 && state[1][i] == state[0][i] && state[1][i] == state[2][i] {
                winner = state[1][i];
                break;
            }
        }

        // check winner: diagonal
        let mid = state[1][1];
        if mid != 0u8 && state[0][0] == mid && state[2][2] == mid {
            winner = mid;
        }
        if mid != 0u8 && state[2][0] == mid && state[0][2] == mid {
            winner = mid;
        }

        if winner != 0u8 {
            println!("\n !! Winner {} ", to_mark(winner));
            break 'outer;
        }

        // CHECK STALEMATE
        let mut stale = true;
        for row in state.iter() {
            for cell in row.iter() {
                if *cell == 0u8 {
                    stale = false;
                }
            }
        }
        if stale {
            println!("\n -- Stalemate");
            break 'outer;
        }

        turn = match turn {
            1u8 => 2u8,
            _ => 1u8,
        }
    }
}