othello/src/repr/board.rs

use super::{bitboard::BitBoard, piece::Piece, CoordAxis, CoordPair};
use arrayvec::ArrayVec;
use const_fn::const_fn;
use rand::seq::IteratorRandom;
use std::{cmp::Ordering, fmt};

/// Map of all points on the board against some type T
/// Used to index like so: example[i][j]
/// with each coordinate
pub struct PosMap<T: Default>(ArrayVec<T, { Board::BOARD_AREA as usize }>);

impl<T: Default> PosMap<T> {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self(ArrayVec::from_iter(
            (0..Board::BOARD_AREA).map(|_| Default::default()),
        ))
    }

    pub fn get(&self, coords: CoordPair) -> &T {
        &self.0[coords.0 as usize]
    }

    pub fn set(&mut self, coords: CoordPair, value: T) {
        self.0[coords.0 as usize] = value;
    }
}

type PosMapOrig<T> = [[T; Board::BOARD_SIZE as usize]; Board::BOARD_SIZE as usize];

impl<T: Default + Copy> From<PosMapOrig<T>> for PosMap<T> {
    fn from(value: PosMapOrig<T>) -> Self {
        let mut new = Self::new();
        for i in 0..Board::BOARD_SIZE {
            for j in 0..Board::BOARD_SIZE {
                new.set((i, j).into(), value[i as usize][j as usize]);
            }
        }
        new
    }
}

#[derive(PartialEq, Eq, Copy, Clone, Debug)]
pub enum Winner {
    Player(Piece),
    Tie,
    None,
}

/// Repersents a Othello game board at a certain space
#[derive(Copy, Clone, PartialEq, Eq)]
pub struct Board {
    /// [`BitBoard`] containing all white pieces
    white_board: BitBoard,

    /// [`BitBoard`] containing all black pieces
    black_board: BitBoard,
}

impl fmt::Display for Board {
    #[allow(clippy::repeat_once)] // clippy gets mad about when PADDING == 1
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let horiz_sep_line = "-".repeat((Self::BOARD_SIZE * 2 + 1) as usize);

        // basically calculates the # of digits BOARD_SIZE needs
        const PADDING: usize = (Board::BOARD_SIZE - 1).ilog10() as usize + 1;

        let space_padding = " ".repeat(PADDING);

        // Print numbers at top so the board can be read more easier
        write!(f, "{} ", space_padding)?;
        for j in (0..Self::BOARD_SIZE).rev() {
            write!(f, "{:0PADDING$} ", j)?;
        }
        writeln!(f)?;

        for i in (0..Self::BOARD_SIZE).rev() {
            writeln!(f, "{}{}", space_padding, horiz_sep_line)?;

            write!(f, "{:0PADDING$}|", i)?;
            for j in (0..Self::BOARD_SIZE).rev() {
                write!(
                    f,
                    "{}|",
                    self.get((i, j).into())
                        .as_ref()
                        .map(Piece::symbol)
                        .unwrap_or(' ')
                )?;
            }
            writeln!(f)?;
        }
        // put a line at the bottom of the board too
        writeln!(f, " {}", horiz_sep_line)?;

        // Print the current score
        write!(
            f,
            "{}",
            [Piece::White, Piece::Black]
                .map(|p| format!("{} Score: {}\n", p.text(), self.count(p)))
                .concat()
        )?;

        Ok(())
    }
}

impl fmt::Debug for Board {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl Board {
    pub const BOARD_SIZE: CoordAxis = 8;

    /// Area of the board
    pub const BOARD_AREA: CoordAxis = Self::BOARD_SIZE.pow(2);

    /// Create a new empty board
    #[allow(clippy::new_without_default)]
    pub const fn new() -> Self {
        Self {
            white_board: BitBoard::new(),
            black_board: BitBoard::new(),
        }
    }

    pub fn random(steps: usize) -> Self {
        let mut new = Self::new().starting_pos();
        let mut p = Piece::Black;
        let mut rng = rand::rng();
        for _ in 0..steps {
            if let Some(m) = new.possible_moves(p).choose(&mut rng) {
                new.place_unchecked(m, p);
            }

            p = !p;
        }

        new
    }

    /// Starting position
    pub const fn starting_pos(mut self) -> Self {
        let hf = Self::BOARD_SIZE / 2;
        self.place_unchecked(CoordPair::from_axes(hf - 1, hf - 1), Piece::White);
        self.place_unchecked(CoordPair::from_axes(hf, hf - 1), Piece::Black);

        self.place_unchecked(CoordPair::from_axes(hf - 1, hf), Piece::Black);
        self.place_unchecked(CoordPair::from_axes(hf, hf), Piece::White);
        self
    }

    /// Provides an iterator of all possible positions on the board
    pub fn all_positions() -> impl Iterator<Item = CoordPair> {
        (0..Self::BOARD_SIZE).flat_map(|i| (0..Self::BOARD_SIZE).map(move |j| (i, j).into()))
    }

    /// Returns an iterator of all possible moves a `color` can make
    pub fn possible_moves(&self, color: Piece) -> impl Iterator<Item = CoordPair> + use<'_> {
        Self::all_positions().filter(move |&coord| self.would_prop(coord, color))
    }

    /// Get a reference to a backing [`BitBoard`]
    const fn board(&self, color: Piece) -> &BitBoard {
        match color {
            Piece::Black => &self.black_board,
            Piece::White => &self.white_board,
        }
    }

    /// Get a mutable reference to a backing [`BitBoard`]
    const fn board_mut(&mut self, color: Piece) -> &mut BitBoard {
        match color {
            Piece::Black => &mut self.black_board,
            Piece::White => &mut self.white_board,
        }
    }

    pub const fn get_piece(&self, coord: CoordPair, color: Piece) -> bool {
        self.board(color).get(coord)
    }

    /// Returns the color of a place on the [`Board`] at a position
    pub const fn get(&self, coord: CoordPair) -> Option<Piece> {
        if self.get_piece(coord, Piece::White) {
            Some(Piece::White)
        } else if self.get_piece(coord, Piece::Black) {
            Some(Piece::Black)
        } else {
            None
        }
    }

    /// Place a piece without checking for propegation of validity
    /// only pub for setting up benchmark
    pub const fn place_unchecked(&mut self, coord: CoordPair, piece: Piece) {
        self.board_mut(piece).set(coord, true);
        self.board_mut(piece.flip()).set(coord, false);
    }

    const fn delete(&mut self, coord: CoordPair) {
        self.board_mut(Piece::White).set(coord, false);
        self.board_mut(Piece::Black).set(coord, false);
    }

    /// Return a modified [`Board`] with the piece placed at a position
    /// Returns None if the move was invalid
    pub fn what_if(&self, coord: CoordPair, piece: Piece) -> Result<Self, &'static str> {
        // extract check here to avoid copy
        if self.get(coord).is_some() {
            return Err("position is occupied");
        }

        let mut self_copy = *self;
        self_copy.place(coord, piece).map(|_| self_copy)
    }

    /// Returns a bool which represents whether or not a move would propegate and be valid
    pub fn would_prop(&self, coord: CoordPair, piece: Piece) -> bool {
        self.get(coord).is_none() && self.propegate_from_dry(coord, piece).count() > 0
    }

    pub fn place(&mut self, coord: CoordPair, piece: Piece) -> Result<(), &'static str> {
        if self.get(coord).is_some() {
            return Err("position is occupied");
        }

        self.place_unchecked(coord, piece);
        if self.propegate_from(coord) == 0 {
            self.delete(coord);
            Err("move would not propegate")
        } else {
            Ok(())
        }
    }

    /// Propegate the board and captures starting from a specific position
    fn propegate_from(&mut self, coord: CoordPair) -> usize {
        let Some(starting_color) = self.get(coord) else {
            return 0;
        };

        let flip_mask = self.propegate_from_dry(coord, starting_color);
        let count = flip_mask.count();

        // Apply the flips
        *self.board_mut(starting_color) |= flip_mask;
        *self.board_mut(starting_color.flip()) &= !flip_mask;

        count
    }

    /// Propegate piece captures originating from (i, j)
    /// DO NOT USE THIS ALONE, this should be called as a part of
    /// [`Board::place`] or [`Board::place_and_prop_unchecked`]
    fn propegate_from_dry(&self, coords: CoordPair, starting_color: Piece) -> BitBoard {
        let player_board = *self.board(starting_color);
        let opponent_board = *self.board(starting_color.flip());

        let mut flip_mask = BitBoard::new();
        let seed = BitBoard::from_coord(coords);

        for dir in BitBoard::DIRECTIONS {
            let mut current = seed;
            let mut temp_flips = BitBoard::new();

            // Expand in direction until edge or non-opponent piece
            loop {
                current = dir(&current);
                if current.count() == 0 || !current.intersects(opponent_board) {
                    break;
                }
                temp_flips |= current;
            }

            // If terminated on a player piece, keep the flips
            if current.intersects(player_board) {
                flip_mask |= temp_flips;
            }
        }

        flip_mask
    }

    /// Count the number of a type of [`Piece`] on the board
    pub const fn count(&self, piece: Piece) -> usize {
        self.board(piece).count()
    }

    /// Get the "net score" of a player
    /// Formula: `net_score = Score_player - Score_opponent`
    pub const fn net_score(&self, piece: Piece) -> i16 {
        self.count(piece) as i16 - self.count(piece.flip()) as i16
    }

    /// Returns the winner of the board (if any)
    pub fn game_winner(&self) -> Winner {
        // Wikipedia: `Players take alternate turns. If one player cannot make a valid move, play passes back to the other player. The game ends when the grid has filled up or if neither player can make a valid move.`

        if self.possible_moves(Piece::Black).next().is_some()
            || self.possible_moves(Piece::White).next().is_some()
        {
            // player can still make a move, there is no winner
            return Winner::None;
        }

        match self.count(Piece::White).cmp(&self.count(Piece::Black)) {
            Ordering::Greater => Winner::Player(Piece::White), // White win
            Ordering::Less => Winner::Player(Piece::Black),    // Black win
            Ordering::Equal => Winner::Tie,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn place_and_get() {
        let mut board = Board::new();
        assert_eq!(board.get((0, 0).into()), None);
        board.place_unchecked((0, 0).into(), Piece::Black);
        assert_eq!(board.get((0, 0).into()), Some(Piece::Black));
    }

    #[test]
    fn place_and_capture_simple() {
        let mut board = Board::new();
        board.place_unchecked((0, 0).into(), Piece::Black);
        board.place_unchecked((0, 1).into(), Piece::White);

        assert_eq!(board.place((0, 2).into(), Piece::Black), Ok(()));

        assert_eq!(board.get((0, 1).into()), Some(Piece::Black));
    }

    #[test]
    fn failed_capture() {
        let mut board = Board::new();

        board.place_unchecked((0, 0).into(), Piece::Black);
        board.place_unchecked((0, 2).into(), Piece::White);

        // should fail
        assert_ne!(board.place((0, 3).into(), Piece::Black), Ok(()));

        assert_eq!(
            board.get((0, 1).into()),
            None,
            "(0, 1) was overridden even though it's an empty space"
        );
    }

    #[test]
    fn long_capture_horiz() {
        let mut board = Board::new();

        board.place_unchecked((0, 0).into(), Piece::Black);

        for j in 1..=6 {
            board.place_unchecked((0, j).into(), Piece::White);
        }

        assert_eq!(board.place((0, 7).into(), Piece::Black), Ok(()));

        for j in 2..=6 {
            assert_eq!(
                board.get((0, j).into()),
                Some(Piece::Black),
                "should be black at: ({}, {})",
                0,
                j
            );
        }
    }

    #[test]
    fn long_capture_vert() {
        let mut board = Board::new();

        board.place_unchecked((0, 0).into(), Piece::Black);

        for i in 1..=6 {
            board.place_unchecked((i, 0).into(), Piece::White);
        }

        assert_eq!(board.place((7, 0).into(), Piece::Black), Ok(()));

        for i in 2..=6 {
            assert_eq!(
                board.get((i, 0).into()),
                Some(Piece::Black),
                "should be black at: ({}, {})",
                i,
                0
            );
        }
    }

    // Test corner capture from top-left corner
    #[test]
    fn corner_capture_top_left() {
        let mut board = Board::new();

        // Black pieces at (2, 2) and (0, 0)
        board.place_unchecked((1, 1).into(), Piece::White); // to be captured
        board.place_unchecked((2, 2).into(), Piece::Black);
        assert_eq!(board.place((0, 0).into(), Piece::Black), Ok(()));

        // Capture white piece at (1,1)
        assert_eq!(board.get((1, 1).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test corner capture from top-right corner
    #[test]
    fn corner_capture_top_right() {
        let mut board = Board::new();

        // Black pieces at (0, 7) and (2, 5)
        board.place_unchecked((0, 7).into(), Piece::Black);
        board.place_unchecked((1, 6).into(), Piece::White); // to be captured
        assert_eq!(board.place((2, 5).into(), Piece::Black), Ok(()));

        // Capture white piece at (1, 6)
        assert_eq!(board.get((1, 6).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test corner capture from bottom-left corner
    #[test]
    fn corner_capture_bottom_left() {
        let mut board = Board::new();

        // Black pieces at (7, 0) and (5, 2)
        board.place_unchecked((7, 0).into(), Piece::Black);
        board.place_unchecked((6, 1).into(), Piece::White); // to be captured
        assert_eq!(board.place((5, 2).into(), Piece::Black), Ok(()));

        // Capture white piece at (6, 1)
        assert_eq!(board.get((6, 1).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test corner capture from bottom-right corner
    #[test]
    fn corner_capture_bottom_right() {
        let mut board = Board::new();

        // Black pieces at (7, 7) and (5, 5)
        board.place_unchecked((7, 7).into(), Piece::Black);
        board.place_unchecked((6, 6).into(), Piece::White); // to be captured
        assert_eq!(board.place((5, 5).into(), Piece::Black), Ok(()));

        // Capture white piece at (6, 6)
        assert_eq!(board.get((6, 6).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from top-left corner (horizontal)
    #[test]
    fn capture_top_left_horiz() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen horizontally from (0, 0)
        board.place_unchecked((0, 0).into(), Piece::Black);
        board.place_unchecked((0, 1).into(), Piece::White); // to be captured
        assert_eq!(board.place((0, 2).into(), Piece::Black), Ok(()));

        assert_eq!(board.get((0, 1).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from top-right corner (horizontal)
    #[test]
    fn capture_top_right_horiz() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen horizontally from (0, 7)
        board.place_unchecked((0, 7).into(), Piece::Black);
        board.place_unchecked((0, 6).into(), Piece::White); // to be captured
        assert_eq!(board.place((0, 5).into(), Piece::Black), Ok(()));

        assert_eq!(board.get((0, 6).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from top-left corner (vertical)
    #[test]
    fn capture_top_left_vert() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen vertically from (0, 0)
        board.place_unchecked((0, 0).into(), Piece::Black);
        board.place_unchecked((1, 0).into(), Piece::White); // to be captured
        assert_eq!(board.place((2, 0).into(), Piece::Black), Ok(()));

        assert_eq!(board.get((1, 0).into()), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from bottom-left corner (vertical)
    #[test]
    fn capture_bottom_left_vert() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen vertically from (7, 0)
        board.place_unchecked((7, 0).into(), Piece::Black);
        board.place_unchecked((6, 0).into(), Piece::White); // to be captured
        assert_eq!(board.place((5, 0).into(), Piece::Black), Ok(()));

        assert_eq!(board.get((6, 0).into()), Some(Piece::Black), "\n{}", board);
    }
}