jingus/othello
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cleaned up, added random AI for testing

Browse source
This commit is contained in:
jackjohn7 2025-11-11 04:10:06 -06:00
parent 92a11f0898
commit b788bd2e4d
5 changed files with 245 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

78
Cargo.lock generated
View file

@ -175,6 +175,18 @@ version = "1.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
[[package]]
name = "getrandom"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
dependencies = [
"cfg-if",
"libc",
"r-efi",
"wasip2",
]
[[package]]
name = "half"
version = "2.7.1"
@ -211,6 +223,12 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "libc"
version = "0.2.177"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
[[package]]
name = "memchr"
version = "2.7.6"
@ -244,6 +262,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"criterion",
"rand",
"regex",
]
@ -275,6 +294,15 @@ dependencies = [
"plotters-backend",
]
[[package]]
name = "ppv-lite86"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
dependencies = [
"zerocopy",
]
[[package]]
name = "proc-macro2"
version = "1.0.103"
@ -293,6 +321,41 @@ dependencies = [
"proc-macro2",
]
[[package]]
name = "r-efi"
version = "5.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
[[package]]
name = "rand"
version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
dependencies = [
"rand_chacha",
"rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
dependencies = [
"getrandom",
]
[[package]]
name = "rayon"
version = "1.11.0"
@ -443,6 +506,15 @@ dependencies = [
"winapi-util",
]
[[package]]
name = "wasip2"
version = "1.0.1+wasi-0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
dependencies = [
"wit-bindgen",
]
[[package]]
name = "wasm-bindgen"
version = "0.2.105"
@ -522,6 +594,12 @@ dependencies = [
"windows-link",
]
[[package]]
name = "wit-bindgen"
version = "0.46.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
[[package]]
name = "zerocopy"
version = "0.8.27"

1
Cargo.toml
View file

@ -17,6 +17,7 @@ regex = "1.12.2"
[dev-dependencies]
criterion = "0.7.0"
rand = "0.9.2"
[[bench]]
name = "generation"

153
src/ai.rs
View file

@ -142,13 +142,123 @@ pub fn alphabeta(mut game: Game, depth: u8, mut alpha: i8, mut beta: i8) -> (Boa
}
}
/// Using alpha-beta pruning with printing of intermediate data for debugging
/// and monitoring purposes.
pub fn alphabeta_with_printing(game: Game, depth: u8) -> (Board, i8) {
let (b, moves, eval) = alphabeta_with_printing_inner(game, depth, i8::MIN + 1, i8::MAX - 1);
println!("beep. boop. we assessed {} moves.", moves);
(b, eval)
}
/// Using alpha-beta pruning and the minimax algorithm, determine the best move
/// for a game with a recursion depth of `depth`.
///
/// We use a very simple evaluation heuristic: (Black squares - White squares).
fn alphabeta_with_printing_inner(
mut game: Game,
depth: u8,
mut alpha: i8,
mut beta: i8,
) -> (Board, usize, i8) {
// if we reach our maximum recursion depth, return evaluation
if depth == 0 {
return (0, 0, game.score().diff());
}
let moves = game.available();
if moves == 0 {
// 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,
0,
alphabeta_with_printing_inner(game, depth - 1, alpha, beta).2,
);
}
// 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::<Vec<_>>();
moves.sort();
let moves = moves
.into_iter()
.map(MoveRank::into_inner)
.collect::<Vec<_>>();
let mut num_moves = moves.len();
// 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 moves {
let mut g = game.clone();
g.play(mv);
// maximize for the evaluation of subsequent moves
let (_, num_moves_prime, evaluation) =
alphabeta_with_printing_inner(g, depth - 1, alpha, beta);
num_moves += num_moves_prime;
// 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;
}
}
(best_move, num_moves, alpha)
}
Team::White => {
for mv in moves {
let mut g = game.clone();
g.play(mv);
// minimize for the evaluation of subsequent moves
let (_, num_moves_prime, evaluation) =
alphabeta_with_printing_inner(g, depth - 1, alpha, beta);
num_moves += num_moves_prime;
// 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;
}
}
(best_move, num_moves, beta)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::board::BitBoard;
use crate::board::view::View;
use crate::board::{BitBoard, Board, Score};
use crate::game::Game;
use rand::prelude::IndexedRandom;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
/// An AI player that only makes random moves
fn random_move(game: &Game, rng: &mut impl Rng) -> Board {
let moves = explode_board(game.available()).collect::<Vec<_>>();
*moves.choose(rng).unwrap()
}
#[test]
// just a sanity check to ensure that my AI performs up to snuff with another popular engine
fn opening() {
@ -171,21 +281,48 @@ mod tests {
// 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.
fn ai_beats_random() {
// just contains pairings of starting_team and seed value
let cases = vec![
(Team::Black, 1231293),
(Team::White, 491823),
(Team::White, 12931),
(Team::Black, 982983713),
(Team::Black, 123),
(Team::White, 87132895),
];
for (team, seed) in cases {
let mut rng = StdRng::seed_from_u64(seed);
let mut game = Game::default();
if team != Team::Black {
let mv = random_move(&game, &mut rng);
game.play(mv);
}
while !game.is_complete() {
if game.available() == 0 {
game.skip();
continue;
}
let mv = if game.current_team == team {
alphabeta(game.clone(), 8, i8::MIN + 1, i8::MAX - 1).0
} else {
let (mv, _) = alphabeta(game.clone(), 8, i8::MIN + 1, i8::MAX - 1);
random_move(&game, &mut rng)
};
game.play(mv);
}
}
// one would assume the AI would compete rather closely against itself.
assert!(dbg!(game.score()).diff().abs() < 3);
assert!(
match (team, game.score()) {
(Team::Black, Score(b, w)) => b - w,
(Team::White, Score(b, w)) => w - b,
} > 4,
"game with seed {} and team {:?} failed to win by 4 points or more.",
seed,
team
);
}
}
#[test]

18
src/cli/mod.rs
View file

@ -1,7 +1,7 @@
use std::io;
use othello::{
ai::alphabeta,
ai::{alphabeta, alphabeta_with_printing},
board::{
Board, Score,
view::{Overlay, View},
@ -15,7 +15,9 @@ use regex::Regex;
enum Action {
Play(Board),
Skip,
Ai,
/// Lets AI play. The boolean value indicates whether or not
/// to enable tracing.
Ai(bool),
}
/// Regex to match on valid play expressions. The file and rank are captured.
@ -68,7 +70,8 @@ pub fn run() -> anyhow::Result<()> {
// match raw strings for other options
match raw_input.as_str().trim() {
"skip" => break Action::Skip,
"ai" => break Action::Ai,
"ai" => break Action::Ai(false),
"ai-trace" => break Action::Ai(true),
_ => println!("Invalid input"),
}
};
@ -95,14 +98,18 @@ pub fn run() -> anyhow::Result<()> {
game.skip()
}
}
Action::Ai => {
Action::Ai(tracing) => {
if legal_moves == 0 {
println!("beep. boop. no legal moves. skipping turn");
game.skip();
} else {
} else if !tracing {
let (mv, eval) = alphabeta(game.clone(), 14, i8::MIN + 1, i8::MAX - 1);
println!("beep. boop. eval = {eval}");
game.play(mv);
} else {
let (mv, eval) = alphabeta_with_printing(game.clone(), 14);
println!("beep. boop. eval = {eval}");
game.play(mv);
}
board_changed = true;
}
@ -141,6 +148,7 @@ fn create_move(file: &str, rank: u8) -> Board {
mod tests {
use super::*;
use othello::board::squares::*;
#[test]
fn create_move_works() {
// validate that we can create moves from

6
src/main.rs
View file

@ -1,6 +1,6 @@
///! Student: Jack Branch - 103-93-063
///! Prof: Dr. Mike O'Neal
///! Class: Artificial Intelligence
// Student: Jack Branch - 103-93-063
// Prof: Dr. Mike O'Neal
// Class: Artificial Intelligence (CS 4753)
mod cli;
fn main() -> anyhow::Result<()> {