diff --git a/README.md b/README.md index c4fd78f..01b6ed6 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,11 @@ # Othello -## Project Structure +## Running -``` -├── iagorithms <-- contains expert system AI library -│   └── ... -├── othello <-- contains main binary and library for Othello -│   └── ... -└── README.md <-- you are here +I recommend using the release profile for the compiler optimizations. These are +quite important since our algorithms involve evaluating millions of moves. +```sh +cargo run --release ``` ## Game Representation @@ -15,6 +13,3 @@ The game state is represented by what's known as a [BitBoard](https://www.chessprogramming.org/Bitboards). I knew about these already from researching Chess programming in the past. - -This does mean that when calling upon iagorithms' it will need to _explode_ -the bitboard into a format that can be pattern matched on. diff --git a/src/ai.rs b/src/ai.rs index 18b35d4..bfad9a9 100644 --- a/src/ai.rs +++ b/src/ai.rs @@ -1,33 +1,119 @@ use crate::{ - board::{Board, explode_board}, + board::{Board, explode_board, squares::*}, game::{Game, Team}, }; +/// Contains all corner squares +const CORNERS: Board = A1 | A8 | H1 | H8; +/// Contains all edge squares +const EDGES: Board = A2 + | A3 + | A4 + | A5 + | A6 + | A7 + | B1 + | B8 + | C1 + | C8 + | D1 + | D8 + | E1 + | E8 + | F1 + | F8 + | G1 + | G8 + | H2 + | H3 + | H4 + | H5 + | H6 + | H7; + +#[derive(PartialEq, Eq, PartialOrd, Ord)] +/// Represents the _value_ of a move. Some moves at face value +/// better than others. +enum MoveRank { + Corner(Board), + Edge(Board), + Other(Board), +} + +impl From for MoveRank { + fn from(value: Board) -> Self { + // Do bitwise operations to check if we have a + // corner or edge move. + if value & CORNERS > 0 { + Self::Corner(value) + } else if value & EDGES > 0 { + Self::Edge(value) + } else { + Self::Other(value) + } + } +} +impl MoveRank { + /// Unwrap underlying move value out of rank structure + fn into_inner(self) -> Board { + match self { + Self::Corner(m) => m, + Self::Edge(m) => m, + Self::Other(m) => m, + } + } +} + /// Using alpha-beta pruning and the minimax algorithm, determine the best move /// for a game with a recursion depth of `depth`. -pub fn alphabeta(game: Game, depth: u8, mut alpha: i8, mut beta: i8) -> (Board, i8) { +/// +/// We use a very simple evaluation heuristic: (Black squares - White squares). +pub fn alphabeta(mut game: Game, depth: u8, mut alpha: i8, mut beta: i8) -> (Board, i8) { + // if we reach our maximum recursion depth, return evaluation if depth == 0 { return (0, game.score().diff()); } let moves = game.available(); if moves == 0 { - return (0, game.score().diff()); + // if no move, skip and continue recursion + // this seems to technically introduce a bias against move-chains + // that include skips. I haven't found it to be a big deal in play. + game.skip(); + return (0, alphabeta(game, depth - 1, alpha, beta).1); } + // just initially assume that the best move is no move at all. This will + // inevitably be corrected. let mut best_move: Board = 0; + // we initially rank moves based on a couple basic heuristics: + // - corner pieces are best + // - edge pieces are great + // - others considered last + // This just allows us to prune the tree a bit more aggressively + // since we're considering the "best" moves first. + // We do this by mapping moves to ranked moves and then sorting. + let mut moves = explode_board(moves).map(MoveRank::from).collect::>(); + moves.sort(); + let moves = moves + .into_iter() + .map(MoveRank::into_inner) + .collect::>(); // I just establish a convention of maximizing for black and minimizing for white. // I'm not sure if that's conventional or not, but it's what I chose. match game.current_team { Team::Black => { - for mv in explode_board(moves) { + for mv in moves { let mut g = game.clone(); g.play(mv); // maximize for the evaluation of subsequent moves let evaluation = alphabeta(g, depth - 1, alpha, beta).1; + // if our evaluated move is superior to the alpha, update + // it. if evaluation > alpha { alpha = evaluation; best_move = mv; }; + // if our beta is less than alpha, prune the node. if beta <= alpha { break; } @@ -35,15 +121,18 @@ pub fn alphabeta(game: Game, depth: u8, mut alpha: i8, mut beta: i8) -> (Board, (best_move, alpha) } Team::White => { - for mv in explode_board(moves) { + for mv in moves { let mut g = game.clone(); g.play(mv); - // maximize for the evaluation of subsequent moves + // minimize for the evaluation of subsequent moves let evaluation = alphabeta(g, depth - 1, alpha, beta).1; + // if our evaluated move produces lower eval than the beta, + // update beta. if evaluation < beta { beta = evaluation; best_move = mv; }; + // if our beta is less than alpha, prune the node. if beta <= alpha { break; } @@ -56,8 +145,8 @@ pub fn alphabeta(game: Game, depth: u8, mut alpha: i8, mut beta: i8) -> (Board, #[cfg(test)] mod tests { use super::*; + use crate::board::BitBoard; use crate::board::view::View; - use crate::board::{BitBoard, squares::*}; use crate::game::Game; #[test] @@ -78,4 +167,36 @@ mod tests { println!("{}", game.board().render(View::RankAsc, vec![])); assert_eq!(best_move, C3); } + + // I found that, despite the AI clobbering me, the AI could not + // compete with itself very well. I'm honestly not quite sure why that is. + #[test] + #[should_panic] // disabled until I fix whatever causes the AI not to tie + fn ai_ties_ai() { + // just play through a game letting AI make all the moves. + let mut game = Game::default(); + while !game.is_complete() { + if game.available() == 0 { + game.skip(); + } else { + let (mv, _) = alphabeta(game.clone(), 8, i8::MIN + 1, i8::MAX - 1); + game.play(mv); + } + } + + // one would assume the AI would compete rather closely against itself. + assert!(dbg!(game.score()).diff().abs() < 3); + } + + #[test] + fn move_ordering() { + let mv = A1 | A8 | C3 | D5 | A4; + let mut moves = explode_board(mv).map(MoveRank::from).collect::>(); + moves.sort(); + let moves = moves + .into_iter() + .map(MoveRank::into_inner) + .collect::>(); + assert_eq!(moves, vec![A1, A8, A4, C3, D5]); + } } diff --git a/src/cli/mod.rs b/src/cli/mod.rs index 7fe6563..bc8bc15 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -18,6 +18,7 @@ enum Action { Ai, } +/// Regex to match on valid play expressions. The file and rank are captured. const PLAY_RE: &str = r"^(play - )?([abcdefghABCDEFGH])(\d)$"; pub fn run() -> anyhow::Result<()> { @@ -26,8 +27,11 @@ pub fn run() -> anyhow::Result<()> { let play_re = Regex::new(PLAY_RE).unwrap(); + // loop until game is complete while !game.is_complete() { + // compute legal moves let legal_moves = game.available(); + // print the board only if we're in a state where we need to if board_changed { let Score(b, w) = game.score(); println!("Score: (Black: {} , White: {}", b, w); @@ -41,13 +45,16 @@ pub fn run() -> anyhow::Result<()> { board_changed = false; } + // in rust, a loop can return a value via `break` + // loop until the user submits a valid choice let choice = loop { println!("Please choose your action: [play - (move), skip, ai]"); let mut raw_input = String::new(); io::stdin() .read_line(&mut raw_input) .context("Failed to read input")?; - if let Some(captures) = play_re.captures(&raw_input.trim()) { + // pattern match on optional regex match for play. + if let Some(captures) = play_re.captures(raw_input.trim()) { let file = captures.get(2).context("Failed to get file capture")?; let rank = captures .get(3) @@ -58,6 +65,7 @@ pub fn run() -> anyhow::Result<()> { break Action::Play(create_move(file.as_str(), rank)); } + // match raw strings for other options match raw_input.as_str().trim() { "skip" => break Action::Skip, "ai" => break Action::Ai, @@ -65,8 +73,10 @@ pub fn run() -> anyhow::Result<()> { } }; + // apply user action by pattern matching match choice { Action::Play(mv) => { + // if move is legal, apply move and re-render if mv & legal_moves == 0 { println!( "Attempted illegal moves. Legal moves are indicated by asterisks (*)." @@ -77,32 +87,36 @@ pub fn run() -> anyhow::Result<()> { } } Action::Skip => { + // only skip if the player has no legal moves if legal_moves != 0 { println!("Cannot skip with legal moves available. Must choose `play` or `ai`."); } else { + board_changed = true; game.skip() } } Action::Ai => { - let (mv, eval) = alphabeta(game.clone(), 12, i8::MIN + 1, i8::MAX - 1); - println!("beep. boop. eval = {eval}"); - game.play(mv); + if legal_moves == 0 { + println!("beep. boop. no legal moves. skipping turn"); + game.skip(); + } else { + let (mv, eval) = alphabeta(game.clone(), 14, i8::MIN + 1, i8::MAX - 1); + println!("beep. boop. eval = {eval}"); + game.play(mv); + } board_changed = true; } } } - game.play(othello::board::squares::E6); - println!(); + let end_score = game.score(); println!( - "{}", - game.board().render( - game.current_team, - vec![Overlay( - game.board().available(game.current_team), - "\x1b[34m*\x1b[37m" - )] - ) + "Game Over!\nScore: Black {} to White {}", + end_score.0, end_score.1 + ); + println!( + "Game board:\n{}", + game.board().render(View::RankAsc, Vec::new()) ); Ok(()) @@ -129,6 +143,8 @@ mod tests { use othello::board::squares::*; #[test] fn create_move_works() { + // validate that we can create moves from + // human-readable data assert_eq!(create_move("a", 1), A1); assert_eq!(create_move("d", 3), D3); assert_eq!(create_move("h", 8), H8); @@ -136,7 +152,9 @@ mod tests { #[test] fn re_works() { + // validate that the regex will match valid move expressions let play_re = Regex::new(PLAY_RE).unwrap(); assert!(play_re.is_match("play - d3")); + assert!(play_re.is_match("d3")); } } diff --git a/src/game.rs b/src/game.rs index c95a735..8eb8b53 100644 --- a/src/game.rs +++ b/src/game.rs @@ -67,6 +67,7 @@ impl Game { pub fn is_complete(&self) -> bool { let score = self.board.score(); score.0 + score.1 == 64 + || (self.board.available(Team::Black) | self.board.available(Team::White) == 0) } } diff --git a/src/main.rs b/src/main.rs index de25299..eaf15f8 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,6 @@ +///! Student: Jack Branch - 103-93-063 +///! Prof: Dr. Mike O'Neal +///! Class: Artificial Intelligence mod cli; fn main() -> anyhow::Result<()> {