bitboard_xo

A XO (aka tic-tac-toe/noughts and crosses) library with focus on minimum memory usage without compromising performance.

Minimum memory usage is achieve using [bitboard], a common data structure in chess, adapted to fit XO game.

The current sizeof XO type is 32 bit, smaller than a pointer in most machine.

Examples

```rust use bitboard_xo::*;

use std::error::Error; use std::io::{stdin, stdout, Write};

/// try read a u8 from console fn readu8() -> Result> { let mut userinput = String::new(); stdin().readline(&mut userinput)?; Ok(user_input.trim().parse()?) }

/// prompt user for input to get xo position fn getxopos() -> XOPos { fn trygetxopos() -> Result> { // prompt user and read row from console print!("Input row : "); stdout().flush()?; let row = readu8()?;

    // prompt user and read col from console
    print!("Input col : ");
    stdout().flush()?;
    let col = read_u8()?;

    // parse row, col into XOPos
    Ok(XOPos::row_col(row, col)?)
};

loop {
    match try_get_xo_pos() {
        Ok(xo_pos) => break xo_pos,
        Err(err) => println!("{}", err),
    }
}

}

fn main() -> Result<(), XOError> { // create new XO game let mut game = XO::new();

loop {
    println!("{}", game);
    // get position from user's input
    let input_xo_pos = get_xo_pos();

    // play at that position and match the returned game state
    match game.play(input_xo_pos) {
        // game end
        Ok(Some(game_result)) => {
            println!("{}", game);
            println!("game result => {:?}", game_result);
            break;
        }
        // game continue
        Ok(None) => println!("game continue..."),
        // some game error occurred
        Err(xo_err) => println!("Error: {}", xo_err),
    }
}

Ok(())

} ``` License: MIT