chessfriend/position/src/move_generator/move_set.rs

// Eryn Wells <eryn@erynwells.me>

use crate::{Move, MoveBuilder};
use chessfriend_bitboard::BitBoard;
use chessfriend_core::{Color, Piece, PlacedPiece, Shape};

#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct BitBoardSet {
    quiet: BitBoard,
    captures: BitBoard,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct MoveListSet {
    quiet: Vec<Move>,
    captures: Vec<Move>,
}

impl MoveListSet {
    pub fn contains(&self, mv: &Move) -> bool {
        self.quiet.contains(mv) || self.captures.contains(mv)
    }
}

/// A set of moves for a piece on the board.
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct MoveSet {
    piece: PlacedPiece,
    bitboards: BitBoardSet,
    move_lists: MoveListSet,
}

impl MoveSet {
    pub(super) fn new(piece: PlacedPiece) -> MoveSet {
        MoveSet {
            piece,
            bitboards: BitBoardSet::default(),
            move_lists: MoveListSet {
                quiet: Vec::new(),
                captures: Vec::new(),
            },
        }
    }

    pub(super) fn quiet_moves(mut self, bitboard: BitBoard) -> MoveSet {
        self.bitboards.quiet = bitboard;
        self
    }

    pub(super) fn capture_moves(mut self, bitboard: BitBoard) -> MoveSet {
        self.bitboards.captures = bitboard;
        self
    }

    /// Return a BitBoard representing all possible moves.
    pub(super) fn bitboard(&self) -> BitBoard {
        self.bitboards.captures | self.bitboards.quiet
    }

    pub(super) fn moves(&self) -> impl Iterator<Item = Move> + '_ {
        let piece = self.piece.piece();
        let from_square = self.piece.square();

        self.bitboards
            .quiet
            .occupied_squares()
            .map(move |to_square| MoveBuilder::new(*piece, from_square, to_square).build())
            .chain(
                self.bitboards
                    .captures
                    .occupied_squares()
                    .map(move |to_square| {
                        MoveBuilder::new(*piece, from_square, to_square)
                            .capturing(PlacedPiece::new(
                                Piece::new(Color::White, Shape::Pawn),
                                to_square,
                            ))
                            .build()
                    }),
            )
    }
}