minmax-rs

minmax-rs/src/connect4/board.rs

@@ -0,0 +1,271 @@
+use std::{
+    fmt::{Display, Write},
+    ops::{Index, IndexMut},
+};
+
+use crate::{Game, Player, Score, State};
+
+type Position = Option<Player>;
+
+const WIDTH: usize = 7;
+const HEIGTH: usize = 4;
+const BOARD_POSITIONS: usize = WIDTH * HEIGTH;
+
+///  0  1  2  3  4  5  6
+///  7  8  9 10 11 12 13
+/// 14 15 16 17 18 19 20
+/// 21 22 23 24 25 26 27
+#[derive(Clone)]
+pub struct Connect4 {
+    positions: [Position; BOARD_POSITIONS],
+}
+
+impl Connect4 {
+    pub fn new() -> Self {
+        Self {
+            positions: [None; BOARD_POSITIONS],
+        }
+    }
+
+    pub fn result(&self) -> State {
+        match self.check_board() {
+            State::Winner(winner) => State::Winner(winner),
+            State::InProgress if self.positions.iter().all(|position| position.is_some()) => {
+                State::Draw
+            }
+            State::InProgress => State::InProgress,
+            State::Draw => unreachable!("check_board cannot tell a draw"),
+        }
+    }
+
+    fn check_board(&self) -> State {
+        self.check_columns()?;
+        self.check_rows()?;
+        self.check_diagonals()
+    }
+
+    fn check_columns(&self) -> State {
+        for i in 0..WIDTH {
+            self.check_four(i, i + WIDTH, i + 2 * WIDTH, i + 3 * WIDTH)?;
+        }
+
+        State::InProgress
+    }
+
+    fn check_rows(&self) -> State {
+        for row_start in 0..HEIGTH {
+            for offset in 0..4 {
+                let start = (row_start * WIDTH) + offset;
+                self.check_four(start, start + 1, start + 2, start + 3)?;
+            }
+        }
+
+        State::InProgress
+    }
+
+    fn check_diagonals(&self) -> State {
+        // */*
+        for start in 3..WIDTH {
+            const DIFF: usize = WIDTH - 1;
+            self.check_four(start, start + DIFF, start + 2 * DIFF, start + 3 * DIFF)?;
+        }
+
+        // *\*
+        for start in 0..4 {
+            const DIFF: usize = WIDTH + 1;
+            self.check_four(start, start + DIFF, start + 2 * DIFF, start + 3 * DIFF)?;
+        }
+        State::InProgress
+    }
+
+    fn check_four(&self, a: usize, b: usize, c: usize, d: usize) -> State {
+        self[a]
+            .map(|player| {
+                if player == self[a] && player == self[b] && player == self[c] && player == self[d]
+                {
+                    State::Winner(player)
+                } else {
+                    State::InProgress
+                }
+            })
+            .unwrap_or(State::InProgress)
+    }
+
+    fn rate(&self, player: Player) -> Score {
+        #[rustfmt::skip]
+        const WIN_COUNT_TABLE: [i32; BOARD_POSITIONS] = [
+            3, 4, 6, 7, 6, 4, 3,
+            2, 4, 6, 7, 6, 4, 2,
+            2, 4, 6, 7, 6, 4, 2,
+            3, 4, 6, 7, 6, 4, 2,
+        ];
+
+        let score_player = |player: Player| {
+            self.positions
+                .iter()
+                .enumerate()
+                .filter(|(_, state)| **state == Some(player))
+                .map(|(pos, _)| WIN_COUNT_TABLE[pos])
+                .sum::<i32>()
+        };
+
+        Score::new(score_player(player) - score_player(player.opponent()))
+    }
+}
+
+impl Index<usize> for Connect4 {
+    type Output = Position;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.positions[index]
+    }
+}
+
+impl IndexMut<usize> for Connect4 {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        &mut self.positions[index]
+    }
+}
+
+impl Game for Connect4 {
+    type Move = usize;
+
+    const REASONABLE_SEARCH_DEPTH: Option<usize> = Some(7);
+
+    fn empty() -> Self {
+        Self::new()
+    }
+
+    fn possible_moves(&self) -> impl Iterator<Item = Self::Move> {
+        let board = self.clone();
+        (0..WIDTH).filter(move |col| board[*col].is_none())
+    }
+
+    fn result(&self) -> State {
+        Connect4::result(&self)
+    }
+
+    fn make_move(&mut self, position: Self::Move, player: Player) {
+        for i in 0..3 {
+            let prev = position + (i * WIDTH);
+            let next = position + ((i + 1) * WIDTH);
+
+            if self[next].is_some() {
+                self[prev] = Some(player);
+                return;
+            }
+        }
+
+        let bottom = position + (3 * WIDTH);
+        self[bottom] = Some(player);
+    }
+
+    fn undo_move(&mut self, position: Self::Move) {
+        for i in 0..4 {
+            let pos = position + (i * WIDTH);
+
+            if self[pos].is_some() {
+                self[pos] = None;
+                return;
+            }
+        }
+    }
+
+    fn rate(&self, player: Player) -> Score {
+        Connect4::rate(&self, player)
+    }
+}
+
+impl Display for Connect4 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for i in 0..HEIGTH {
+            for j in 0..WIDTH {
+                let index = (i * WIDTH) + j;
+                match self[index] {
+                    Some(Player::X) => {
+                        write!(f, "\x1B[31m  X\x1B[0m  ")?;
+                    }
+                    Some(Player::O) => {
+                        write!(f, "\x1B[34m  O\x1B[0m  ")?;
+                    }
+                    None => {
+                        write!(f, "\x1B[35m{index:3 }\x1B[0m  ")?;
+                    }
+                }
+            }
+            f.write_char('\n')?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{Player, State};
+
+    use super::Connect4;
+
+    fn parse_board(board: &str) -> Connect4 {
+        let positions = board
+            .chars()
+            .filter(|char| !char.is_whitespace())
+            .map(|char| match char {
+                'X' => Some(Player::X),
+                'O' => Some(Player::O),
+                '_' => None,
+                char => panic!("Invalid char in board: `{char}`"),
+            })
+            .collect::<Vec<_>>()
+            .try_into()
+            .expect(&format!(
+                "not enough positions provided: {}",
+                board.chars().filter(|c| !c.is_whitespace()).count()
+            ));
+
+        Connect4 { positions }
+    }
+
+    fn test(board: &str, state: State) {
+        let board = parse_board(board);
+        assert_eq!(board.result(), state);
+    }
+
+    #[test]
+    fn draw() {
+        test(
+            "
+        XOOOXOX
+        XOOOXOX
+        OXXXOXO
+        XOOOXXX
+        ",
+            State::Draw,
+        );
+    }
+
+    #[test]
+    fn full_winner() {
+        test(
+            "
+        XOOOXOX
+        XOOOXOX
+        OXXXOXO
+        XOOOXOX
+        ",
+            State::Winner(Player::O),
+        );
+    }
+
+    #[test]
+    fn three_rows() {
+        test(
+            "
+        XXX_OOO
+        _XXX___
+        X_OOO__
+        OOO____
+        ",
+            State::InProgress,
+        );
+    }
+}

minmax-rs/src/connect4/mod.rs

@@ -0,0 +1,6 @@
+use self::board::Connect4;
+
+pub use player::HumanPlayer;
+
+pub mod board;
+pub mod player;

minmax-rs/src/connect4/player.rs

@@ -0,0 +1,35 @@
+use std::io::Write;
+
+use crate::{Game, GamePlayer, Player};
+
+use super::Connect4;
+
+#[derive(Clone, Default)]
+pub struct HumanPlayer;
+
+impl GamePlayer<Connect4> for HumanPlayer {
+    fn next_move(&mut self, board: &mut Connect4, this_player: Player) {
+        loop {
+            print!("{board}where to put the next {this_player}? (0-7): ");
+
+            std::io::stdout().flush().unwrap();
+            let mut buf = String::new();
+            std::io::stdin().read_line(&mut buf).unwrap();
+
+            match buf.trim().parse() {
+                Ok(number) if number < 7 => match board[number] {
+                    None => {
+                        board.make_move(number, this_player);
+                        return;
+                    }
+                    Some(_) => {
+                        println!("Field is occupied already.")
+                    }
+                },
+                Ok(_) | Err(_) => {
+                    println!("Invalid input.")
+                }
+            }
+        }
+    }
+}

minmax-rs/src/lib.rs

@@ -0,0 +1,108 @@
+#![feature(
+    never_type,
+    try_trait_v2,
+    return_position_impl_trait_in_trait,
+    let_chains
+)]
+#![allow(incomplete_features)]
+
+pub mod connect4;
+mod minmax;
+pub mod tic_tac_toe;
+
+mod player;
+
+use std::{fmt::Display, ops::Neg};
+
+pub use self::minmax::PerfectPlayer;
+pub use player::{Player, State};
+
+pub trait GamePlayer<G: ?Sized + Game> {
+    fn next_move(&mut self, board: &mut G, this_player: Player);
+}
+
+impl<G: Game, P: GamePlayer<G> + ?Sized> GamePlayer<G> for &mut P {
+    fn next_move(&mut self, board: &mut G, this_player: Player) {
+        P::next_move(self, board, this_player)
+    }
+}
+
+
+impl<G: Game, P: GamePlayer<G> + ?Sized> GamePlayer<G> for Box<P> {
+    fn next_move(&mut self, board: &mut G, this_player: Player) {
+        P::next_move(self, board, this_player)
+    }
+}
+
+pub trait Game: Display {
+    type Move: Copy;
+
+    const REASONABLE_SEARCH_DEPTH: Option<usize>;
+
+    fn empty() -> Self;
+
+    fn possible_moves(&self) -> impl Iterator<Item = Self::Move>;
+
+    fn result(&self) -> State;
+
+    /// Only called if [`GameBoard::REASONABLE_SEARCH_DEPTH`] is `Some`.
+    fn rate(&self, player: Player) -> Score;
+
+    fn make_move(&mut self, position: Self::Move, player: Player);
+
+    fn undo_move(&mut self, position: Self::Move);
+
+    fn play<A: GamePlayer<Self>, B: GamePlayer<Self>>(
+        &mut self,
+        x: &mut A,
+        o: &mut B,
+    ) -> Option<Player> {
+        let mut current_player = Player::X;
+
+        loop {
+            if current_player == Player::X {
+                x.next_move(self, current_player);
+            } else {
+                o.next_move(self, current_player);
+            }
+
+            match self.result() {
+                State::Winner(player) => return Some(player),
+                State::Draw => {
+                    return None;
+                }
+                State::InProgress => {}
+            }
+
+            current_player = current_player.opponent();
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Score(i32);
+
+impl Score {
+    const MIN: Self = Self(i32::MIN);
+    const LOST: Self = Self(-100);
+    const TIE: Self = Self(0);
+    const WON: Self = Self(100);
+
+    pub fn new(int: i32) -> Self {
+        Self(int)
+    }
+
+    fn randomize(self) -> Self {
+        let score = self.0 as f32;
+        let rand = rand::thread_rng();
+        self
+    }
+}
+
+impl Neg for Score {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(-self.0)
+    }
+}

minmax-rs/src/main.rs

@@ -0,0 +1,156 @@
+#![feature(let_chains)]
+
+use std::{fmt::Display, str::FromStr, time::SystemTime};
+
+use clap::{Parser, ValueEnum};
+use minmax::{
+    connect4::{self, board::Connect4},
+    tic_tac_toe::{self, TicTacToe},
+    Game, GamePlayer, PerfectPlayer, Player,
+};
+
+#[derive(Debug, Clone)]
+enum PlayerConfig {
+    Human,
+    Perfect { depth: Option<usize> },
+}
+
+impl FromStr for PlayerConfig {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split(":");
+        let mut player = match parts
+            .next()
+            .ok_or_else(|| "No player name provided".to_owned())?
+        {
+            "human" | "h" => Self::Human,
+            "perfect" | "p" | "ai" | "minmax" => Self::Perfect { depth: None },
+            string => {
+                return Err(format!(
+                    "Invalid player: {string}. Available players: human,perfect"
+                ))
+            }
+        };
+
+        if let Some(depth) = parts.next()
+            && let Self::Perfect { depth: player_depth } = &mut player
+        {
+            match depth.parse() {
+                Ok(depth) => *player_depth = Some(depth),
+                Err(err) => return Err(format!("Invalid depth: {depth}. {err}")),
+            }
+        }
+
+        Ok(player)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+enum GameType {
+    TicTacToe,
+    Connect4,
+}
+
+#[derive(Debug, Parser)]
+#[command(author, version, about)]
+struct Args {
+    #[arg(short, long)]
+    game: GameType,
+    #[arg(short)]
+    x: PlayerConfig,
+    #[arg(short)]
+    o: PlayerConfig,
+    #[arg(long)]
+    no_print_time: bool,
+}
+
+fn main() {
+    let args = Args::parse();
+
+    match args.game {
+        GameType::Connect4 => {
+            let get_player = |player| -> Box<dyn GamePlayer<Connect4>> {
+                match player {
+                    PlayerConfig::Human => Box::new(connect4::HumanPlayer),
+                    PlayerConfig::Perfect { depth } => {
+                        Box::new(PerfectPlayer::new(!args.no_print_time).with_max_depth(depth))
+                    }
+                }
+            };
+
+            let player_a = get_player(args.o);
+            let player_b = get_player(args.x);
+
+            play_with_players(player_a, player_b);
+        }
+        GameType::TicTacToe => {
+            let get_player = |player| -> Box<dyn GamePlayer<TicTacToe>> {
+                match player {
+                    PlayerConfig::Human => Box::new(tic_tac_toe::HumanPlayer),
+                    PlayerConfig::Perfect { depth } => {
+                        Box::new(PerfectPlayer::new(!args.no_print_time).with_max_depth(depth))
+                    }
+                }
+            };
+
+            let player_a = get_player(args.o);
+            let player_b = get_player(args.x);
+
+            play_with_players(player_a, player_b);
+        }
+    }
+}
+
+#[allow(dead_code)]
+fn tic_tac_toe_stats() {
+    let mut results = [0, 0, 0];
+
+    let start = SystemTime::now();
+
+    for _ in 0..100 {
+        let result = play::<PerfectPlayer<TicTacToe>, tic_tac_toe::GreedyPlayer, _>(false);
+        let idx = Player::as_u8(result);
+        results[idx as usize] += 1;
+    }
+
+    println!("Winner counts");
+    println!(" X: {}", results[0]);
+    println!(" O: {}", results[1]);
+    println!(" Draw: {}", results[2]);
+
+    let time = start.elapsed().unwrap();
+
+    println!("Completed in {}ms", time.as_millis());
+}
+
+fn play_with_players<G: Game, X: GamePlayer<G>, O: GamePlayer<G>>(mut x: X, mut o: O) {
+    let mut board = G::empty();
+    let result = board.play(&mut x, &mut o);
+
+    print_result(result, board);
+}
+
+fn play<X: GamePlayer<G> + Default, O: GamePlayer<G> + Default, G: Game>(
+    print: bool,
+) -> Option<Player> {
+    let mut board = G::empty();
+    let result = board.play(&mut X::default(), &mut O::default());
+    if print {
+        print_result(result, board);
+    }
+    result
+}
+
+fn print_result(result: Option<Player>, board: impl Display) {
+    println!("{board}");
+
+    match result {
+        Some(winner) => {
+            println!("player {winner} won!");
+        }
+        None => {
+            println!("a draw...")
+        }
+    }
+}

minmax-rs/src/minmax.rs

@@ -0,0 +1,82 @@
+use std::time::Instant;
+
+use crate::{Game, GamePlayer, Player, Score, State};
+
+#[derive(Clone)]
+pub struct PerfectPlayer<G: Game> {
+    best_move: Option<G::Move>,
+    max_depth: Option<usize>,
+    print_time: bool,
+}
+
+impl<G: Game> Default for PerfectPlayer<G> {
+    fn default() -> Self {
+        Self::new(true)
+    }
+}
+
+impl<G: Game> PerfectPlayer<G> {
+    pub fn new(print_time: bool) -> Self {
+        Self {
+            best_move: None,
+            max_depth: G::REASONABLE_SEARCH_DEPTH,
+            print_time,
+        }
+    }
+
+    pub fn with_max_depth(mut self, max_depth: Option<usize>) -> Self {
+        self.max_depth = max_depth;
+        self
+    }
+
+    fn minmax(&mut self, board: &mut G, player: Player, depth: usize) -> Score {
+        if let Some(max_depth) = self.max_depth && depth >= max_depth {
+            return board.rate(player);
+        }
+
+        match board.result() {
+            State::Winner(winner) => {
+                if winner == player {
+                    Score::WON
+                } else {
+                    Score::LOST
+                }
+            }
+            State::Draw => Score::TIE,
+            State::InProgress => {
+                let mut max_value = Score::MIN;
+
+                for pos in board.possible_moves() {
+                    board.make_move(pos, player);
+                    let value = -self.minmax(board, player.opponent(), depth + 1);
+
+                    board.undo_move(pos);
+
+                    if value > max_value {
+                        max_value = value;
+                        if depth == 0 {
+                            self.best_move = Some(pos);
+                        }
+                    }
+                }
+
+                max_value
+            }
+        }
+    }
+}
+
+impl<G: Game> GamePlayer<G> for PerfectPlayer<G> {
+    fn next_move(&mut self, board: &mut G, this_player: Player) {
+        let start = Instant::now();
+        self.best_move = None;
+        self.minmax(board, this_player, 0);
+
+        board.make_move(self.best_move.expect("could not make move"), this_player);
+
+        if self.print_time {
+            let duration = start.elapsed();
+            println!("Move took {duration:?}");
+        }
+    }
+}

minmax-rs/src/player.rs

@@ -0,0 +1,86 @@
+use std::{
+    fmt::Display,
+    ops::{ControlFlow, Try},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Player {
+    X,
+    O,
+}
+
+impl PartialEq<Option<Player>> for Player {
+    fn eq(&self, other: &Option<Player>) -> bool {
+        match (self, other) {
+            (Player::X, Some(Player::X)) => true,
+            (Player::O, Some(Player::O)) => true,
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum State {
+    Winner(Player),
+    InProgress,
+    Draw,
+}
+
+impl Player {
+    pub fn opponent(self) -> Self {
+        match self {
+            Self::X => Self::O,
+            Self::O => Self::X,
+        }
+    }
+
+    pub fn from_u8(num: u8) -> Result<Option<Self>, ()> {
+        Ok(match num {
+            0 => Some(Player::X),
+            1 => Some(Player::O),
+            2 => None,
+            _ => return Err(()),
+        })
+    }
+
+    pub fn as_u8(this: Option<Player>) -> u8 {
+        match this {
+            Some(Player::X) => 0,
+            Some(Player::O) => 1,
+            None => 2,
+        }
+    }
+}
+
+impl Display for Player {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::X => "X",
+            Self::O => "O",
+        })
+    }
+}
+
+impl std::ops::FromResidual for State {
+    fn from_residual(residual: <Self as Try>::Residual) -> Self {
+        residual
+    }
+}
+
+impl Try for State {
+    // InProgress
+    type Output = Self;
+
+    type Residual = Self;
+
+    fn from_output(_: Self::Output) -> Self {
+        Self::InProgress
+    }
+
+    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+        match self {
+            Self::InProgress => ControlFlow::Continue(self),
+            Self::Winner(_) | Self::Draw => ControlFlow::Break(self),
+        }
+    }
+}

minmax-rs/src/tic_tac_toe/board.rs

@@ -0,0 +1,184 @@
+use std::fmt::{Display, Write};
+
+use crate::{Game, Player, Score, State};
+
+#[derive(Clone)]
+pub struct TicTacToe(u32);
+
+impl TicTacToe {
+    pub fn empty() -> Self {
+        // A = 1010
+        // 18 bits - 9 * 2 bits - 4.5 nibbles
+        Self(0x0002AAAA)
+    }
+
+    fn validate(&self) {
+        if cfg!(debug_assertions) {
+            let board = self.0;
+            for i in 0..16 {
+                let next_step = board >> (i * 2);
+                let mask = 0b11;
+                let pos = next_step & mask;
+                if pos >= 3 {
+                    panic!("Invalid bits, self: {board:0X}, bits: {pos:0X}");
+                }
+            }
+        }
+    }
+
+    pub fn get(&self, index: usize) -> Option<Player> {
+        debug_assert!(index < 9);
+
+        let board = self.0;
+
+        let shifted = board >> (index * 2);
+        let masked = shifted & 0b11;
+
+        // SAFETY: So uh, this is a bit unlucky.
+        // You see, there are two entire bits of information at our disposal for each position.
+        // This is really bad. We only have three valid states. So we need to do _something_ if it's invalid.
+        // We just hope that it will never be invalid which it really shouldn't be and also have a debug assertion
+        // here to make sure that it really is valid and then if it's not invalid we just mov it out and are happy.
+        self.validate();
+        unsafe { Player::from_u8(masked as u8).unwrap_unchecked() }
+    }
+
+    pub fn set(&mut self, index: usize, value: Option<Player>) {
+        debug_assert!(index < 9);
+        self.validate();
+
+        let value = Player::as_u8(value) as u32;
+
+        let value = value << (index * 2);
+        let mask = 0b11 << (index * 2);
+
+        let current_masked_off_new = self.0 & !mask;
+        let result = value | current_masked_off_new;
+        self.0 = result;
+
+        self.validate();
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = Option<Player>> {
+        let mut i = 0;
+        let this = self.clone();
+        std::iter::from_fn(move || {
+            let result = (i < 9).then(|| this.get(i));
+            i += 1;
+            result
+        })
+    }
+
+    pub fn result(&self) -> State {
+        win_table::result(self)
+    }
+}
+
+mod win_table {
+    use super::TicTacToe;
+    use crate::{Player, State};
+
+    const WIN_TABLE_SIZE: usize = 2usize.pow(2 * 9);
+    static WIN_TABLE: &[u8; WIN_TABLE_SIZE] =
+        include_bytes!(concat!(env!("OUT_DIR"), "/win_table"));
+
+    pub fn result(board: &TicTacToe) -> State {
+        match WIN_TABLE[board.0 as usize] {
+            0 => State::Winner(Player::X),
+            1 => State::Winner(Player::X),
+            2 => State::InProgress,
+            3 => State::Draw,
+            n => panic!("Invalid value {n} in table"),
+        }
+    }
+}
+
+impl Display for TicTacToe {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for i in 0..3 {
+            for j in 0..3 {
+                let index = i * 3 + j;
+                match self.get(index) {
+                    Some(player) => {
+                        write!(f, "\x1B[33m{player}\x1B[0m  ")?;
+                    }
+                    None => {
+                        write!(f, "\x1B[35m{index}\x1B[0m  ")?;
+                    }
+                }
+            }
+            f.write_char('\n')?;
+        }
+        Ok(())
+    }
+}
+
+impl Game for TicTacToe {
+    type Move = usize;
+
+    const REASONABLE_SEARCH_DEPTH: Option<usize> = None;
+
+    fn empty() -> Self {
+        Self::empty()
+    }
+
+    fn possible_moves(&self) -> impl Iterator<Item = Self::Move> {
+        debug_assert!(
+            !self.iter().all(|x| x.is_some()),
+            "the board is full but state is InProgress"
+        );
+
+        self.iter()
+            .enumerate()
+            .filter(|(_, position)| position.is_none())
+            .map(|(pos, _)| pos)
+    }
+
+    fn result(&self) -> State {
+        TicTacToe::result(self)
+    }
+
+    fn rate(&self, _: Player) -> Score {
+        unimplemented!("we always finish the board")
+    }
+
+    fn make_move(&mut self, position: Self::Move, player: Player) {
+        self.set(position, Some(player));
+    }
+
+    fn undo_move(&mut self, position: Self::Move) {
+        self.set(position, None);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Player, TicTacToe};
+
+    #[test]
+    fn board_field() {
+        let mut board = TicTacToe::empty();
+        board.set(0, None);
+        board.set(8, Some(Player::X));
+        board.set(4, Some(Player::O));
+        board.set(5, Some(Player::X));
+
+        let expected = [
+            None,
+            None,
+            None,
+            None,
+            Some(Player::O),
+            Some(Player::X),
+            None,
+            None,
+            Some(Player::X),
+        ];
+
+        board
+            .iter()
+            .zip(expected.into_iter())
+            .enumerate()
+            .for_each(|(idx, (actual, expected))| assert_eq!(actual, expected, "Position {idx}"));
+    }
+}

minmax-rs/src/tic_tac_toe/game.rs

@@ -0,0 +1,33 @@
+use crate::{GamePlayer, Player, State};
+
+use super::TicTacToe;
+
+impl TicTacToe {
+    pub fn play<A: GamePlayer<TicTacToe>, B: GamePlayer<TicTacToe>>(
+        &mut self,
+        x: &mut A,
+        o: &mut B,
+    ) -> Option<Player> {
+        let mut current_player = Player::X;
+
+        for _ in 0..9 {
+            if current_player == Player::X {
+                x.next_move(self, current_player);
+            } else {
+                o.next_move(self, current_player);
+            }
+
+            match self.result() {
+                State::Winner(player) => return Some(player),
+                State::Draw => {
+                    return None;
+                }
+                State::InProgress => {}
+            }
+
+            current_player = current_player.opponent();
+        }
+
+        None
+    }
+}

minmax-rs/src/tic_tac_toe/mod.rs

@@ -0,0 +1,43 @@
+mod board;
+mod game;
+mod player;
+
+pub use {board::TicTacToe, player::*};
+
+#[cfg(test)]
+mod tests {
+    use crate::{minmax::PerfectPlayer, tic_tac_toe::board::TicTacToe, GamePlayer, Player};
+
+    use super::player::{GreedyPlayer, RandomPlayer};
+
+    fn assert_win_ratio<X: GamePlayer<TicTacToe>, O: GamePlayer<TicTacToe>>(
+        runs: u64,
+        x_win_ratio: f64,
+        x: impl Fn() -> X,
+        o: impl Fn() -> O,
+    ) {
+        let mut results = [0u64, 0, 0];
+
+        for _ in 0..runs {
+            let result = TicTacToe::empty().play::<X, O>(&mut x(), &mut o());
+            let idx = Player::as_u8(result);
+            results[idx as usize] += 1;
+        }
+
+        let total = results.iter().copied().sum::<u64>();
+
+        let ratio = (total as f64) / (results[0] as f64);
+        println!("{ratio} >= {x_win_ratio}");
+        assert!(ratio >= x_win_ratio);
+    }
+
+    #[test]
+    fn perfect_always_beats_greedy() {
+        assert_win_ratio(20, 1.0, || PerfectPlayer::new(false), || GreedyPlayer);
+    }
+
+    #[test]
+    fn perfect_beats_random() {
+        assert_win_ratio(10, 0.95, || PerfectPlayer::new(false), || RandomPlayer);
+    }
+}

minmax-rs/src/tic_tac_toe/player.rs

@@ -0,0 +1,65 @@
+use std::io::Write;
+
+use rand::Rng;
+
+use crate::{GamePlayer, Player};
+
+use super::TicTacToe;
+
+#[derive(Clone, Default)]
+pub struct GreedyPlayer;
+
+impl GamePlayer<TicTacToe> for GreedyPlayer {
+    fn next_move(&mut self, board: &mut TicTacToe, this_player: Player) {
+        let first_free = board.iter().position(|p| p.is_none()).unwrap();
+        board.set(first_free, Some(this_player));
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct HumanPlayer;
+
+impl GamePlayer<TicTacToe> for HumanPlayer {
+    fn next_move(&mut self, board: &mut TicTacToe, this_player: Player) {
+        loop {
+            print!("{board}where to put the next {this_player}? (0-8): ");
+
+            std::io::stdout().flush().unwrap();
+            let mut buf = String::new();
+            std::io::stdin().read_line(&mut buf).unwrap();
+
+            match buf.trim().parse() {
+                Ok(number) if number < 9 => match board.get(number) {
+                    None => {
+                        board.set(number, Some(this_player));
+                        return;
+                    }
+                    Some(_) => {
+                        println!("Field is occupied already.")
+                    }
+                },
+                Ok(_) | Err(_) => {
+                    println!("Invalid input.")
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct RandomPlayer;
+
+impl GamePlayer<TicTacToe> for RandomPlayer {
+    fn next_move(&mut self, board: &mut TicTacToe, this_player: Player) {
+        loop {
+            let next = rand::thread_rng().gen_range(0..9);
+            match board.get(next) {
+                Some(_) => {}
+                None => {
+                    board.set(next, Some(this_player));
+                    return;
+                }
+            }
+        }
+    }
+}