diff --git a/src/attack.rs b/src/attack.rs index 5465188..e65010a 100644 --- a/src/attack.rs +++ b/src/attack.rs @@ -316,31 +316,31 @@ pub fn init_attacks() { #[cfg(test)] mod tests { use super::*; - use crate::board::{Color, Kind, Piece}; + use crate::board::{Color, Piece, PieceType}; #[test] fn test_pawn_attacks() -> Result<(), String> { - let white_pawn_a_file = Piece::new(0x100, Kind::Pawn, Color::White); + let white_pawn_a_file = Piece::new(0x100, PieceType::Pawn, Color::White); let attacks = pawn_attacks(white_pawn_a_file.bitboard, white_pawn_a_file.color); assert_eq!(attacks, 0x20000); - let white_pawn_b_file = Piece::new(0x200, Kind::Pawn, Color::White); + let white_pawn_b_file = Piece::new(0x200, PieceType::Pawn, Color::White); let attacks = pawn_attacks(white_pawn_b_file.bitboard, white_pawn_b_file.color); assert_eq!(attacks, 0x50000); - let white_pawn_h_file = Piece::new(0x8000, Kind::Pawn, Color::White); + let white_pawn_h_file = Piece::new(0x8000, PieceType::Pawn, Color::White); let attacks = pawn_attacks(white_pawn_h_file.bitboard, white_pawn_h_file.color); assert_eq!(attacks, 0x400000); - let black_pawn_a_file = Piece::new(0x1000000000000, Kind::Pawn, Color::Black); + let black_pawn_a_file = Piece::new(0x1000000000000, PieceType::Pawn, Color::Black); let attacks = pawn_attacks(black_pawn_a_file.bitboard, black_pawn_a_file.color); assert_eq!(attacks, 0x20000000000); - let black_pawn_b_file = Piece::new(0x2000000000000, Kind::Pawn, Color::Black); + let black_pawn_b_file = Piece::new(0x2000000000000, PieceType::Pawn, Color::Black); let attacks = pawn_attacks(black_pawn_b_file.bitboard, black_pawn_b_file.color); assert_eq!(attacks, 0x50000000000); - let black_pawn_h_file = Piece::new(0x80000000000000, Kind::Pawn, Color::Black); + let black_pawn_h_file = Piece::new(0x80000000000000, PieceType::Pawn, Color::Black); let attacks = pawn_attacks(black_pawn_h_file.bitboard, black_pawn_h_file.color); assert_eq!(attacks, 0x400000000000); @@ -349,23 +349,23 @@ mod tests { #[test] fn test_knight_attacks() -> Result<(), String> { - let knight_two_attacks = Piece::new(0x1, Kind::Knight, Color::White); + let knight_two_attacks = Piece::new(0x1, PieceType::Knight, Color::White); let attacks = knight_attacks(knight_two_attacks.bitboard); assert_eq!(attacks, 0x20400); - let knight_three_attacks = Piece::new(0x2, Kind::Knight, Color::White); + let knight_three_attacks = Piece::new(0x2, PieceType::Knight, Color::White); let attacks = knight_attacks(knight_three_attacks.bitboard); assert_eq!(attacks, 0x50800); - let knight_three_attacks = Piece::new(0x4, Kind::Knight, Color::White); + let knight_three_attacks = Piece::new(0x4, PieceType::Knight, Color::White); let attacks = knight_attacks(knight_three_attacks.bitboard); assert_eq!(attacks, 0xa1100); - let knight_six_attacks = Piece::new(0x400, Kind::Knight, Color::White); + let knight_six_attacks = Piece::new(0x400, PieceType::Knight, Color::White); let attacks = knight_attacks(knight_six_attacks.bitboard); assert_eq!(attacks, 0xa110011); - let knight_eight_attacks = Piece::new(0x40000, Kind::Knight, Color::White); + let knight_eight_attacks = Piece::new(0x40000, PieceType::Knight, Color::White); let attacks = knight_attacks(knight_eight_attacks.bitboard); assert_eq!(attacks, 0xa1100110a); @@ -374,15 +374,15 @@ mod tests { #[test] fn test_king_attacks() -> Result<(), String> { - let king_three_attacks = Piece::new(0x1, Kind::King, Color::White); + let king_three_attacks = Piece::new(0x1, PieceType::King, Color::White); let attacks = king_attacks(king_three_attacks.bitboard); assert_eq!(attacks, 0x302); - let king_five_attacks = Piece::new(0x2, Kind::King, Color::White); + let king_five_attacks = Piece::new(0x2, PieceType::King, Color::White); let attacks = king_attacks(king_five_attacks.bitboard); assert_eq!(attacks, 0x705); - let king_eight_attacks = Piece::new(0x200, Kind::King, Color::White); + let king_eight_attacks = Piece::new(0x200, PieceType::King, Color::White); let attacks = king_attacks(king_eight_attacks.bitboard); assert_eq!(attacks, 0x70507); @@ -391,7 +391,7 @@ mod tests { #[test] fn test_mask_bishop_attacks() -> Result<(), String> { - let bishop_d4 = Piece::new(0x8000000, Kind::Bishop, Color::White); + let bishop_d4 = Piece::new(0x8000000, PieceType::Bishop, Color::White); let all_directions_mask = mask_bishop_attacks(bishop_d4.bitboard); assert_eq!(all_directions_mask, 0x40221400142200); @@ -400,12 +400,12 @@ mod tests { #[test] fn test_bishop_attacks_on_the_fly() -> Result<(), String> { - let bishop_d4 = Piece::new(0x8000000, Kind::Bishop, Color::White); + let bishop_d4 = Piece::new(0x8000000, PieceType::Bishop, Color::White); let blocker_c5 = 0x400000000_u64; let attacks = bishop_attacks_on_the_fly(bishop_d4.bitboard, blocker_c5); assert_eq!(attacks, 0x8040201400142241); - let bishop_a1 = Piece::new(0x0, Kind::Bishop, Color::White); + let bishop_a1 = Piece::new(0x0, PieceType::Bishop, Color::White); let blocker_none = 0x0_u64; let attacks = bishop_attacks_on_the_fly(bishop_a1.bitboard, blocker_none); assert_eq!(attacks, 0x8040201008040200); @@ -415,7 +415,7 @@ mod tests { #[test] fn test_mask_rook_attacks() -> Result<(), String> { - let rook_d4 = Piece::new(0x8000000, Kind::Rook, Color::White); + let rook_d4 = Piece::new(0x8000000, PieceType::Rook, Color::White); let all_directions_mask = mask_rook_attacks(rook_d4.bitboard); assert_eq!(all_directions_mask, 0x8080876080800); @@ -424,7 +424,7 @@ mod tests { #[test] fn test_rook_attacks_on_the_fly() -> Result<(), String> { - let rook_d4 = Piece::new(0x8000000, Kind::Rook, Color::White); + let rook_d4 = Piece::new(0x8000000, PieceType::Rook, Color::White); let blocker_c4 = 0x4000000_u64; let attacks = rook_attacks_on_the_fly(rook_d4.bitboard, blocker_c4); assert_eq!(attacks, 0x8080808f4080808); diff --git a/src/board.rs b/src/board.rs index 72c919b..f5943e5 100644 --- a/src/board.rs +++ b/src/board.rs @@ -23,20 +23,20 @@ impl Board { pub const fn new() -> Self { Self { white_pieces: [ - Piece::new(0xff00, Kind::Pawn, Color::White), - Piece::new(0x42, Kind::Knight, Color::White), - Piece::new(0x24, Kind::Bishop, Color::White), - Piece::new(0x81, Kind::Rook, Color::White), - Piece::new(0x8, Kind::Queen, Color::White), - Piece::new(0x10, Kind::King, Color::White), + Piece::new(0xff00, PieceType::Pawn, Color::White), + Piece::new(0x42, PieceType::Knight, Color::White), + Piece::new(0x24, PieceType::Bishop, Color::White), + Piece::new(0x81, PieceType::Rook, Color::White), + Piece::new(0x8, PieceType::Queen, Color::White), + Piece::new(0x10, PieceType::King, Color::White), ], black_pieces: [ - Piece::new(0xff000000000000, Kind::Pawn, Color::Black), - Piece::new(0x4200000000000000, Kind::Knight, Color::Black), - Piece::new(0x2400000000000000, Kind::Bishop, Color::Black), - Piece::new(0x8100000000000000, Kind::Rook, Color::Black), - Piece::new(0x800000000000000, Kind::Queen, Color::Black), - Piece::new(0x1000000000000000, Kind::King, Color::Black), + Piece::new(0xff000000000000, PieceType::Pawn, Color::Black), + Piece::new(0x4200000000000000, PieceType::Knight, Color::Black), + Piece::new(0x2400000000000000, PieceType::Bishop, Color::Black), + Piece::new(0x8100000000000000, PieceType::Rook, Color::Black), + Piece::new(0x800000000000000, PieceType::Queen, Color::Black), + Piece::new(0x1000000000000000, PieceType::King, Color::Black), ], state: State::new(), } @@ -45,20 +45,20 @@ impl Board { pub const fn empty_board() -> Self { Self { white_pieces: [ - Piece::new(0x0, Kind::Pawn, Color::White), - Piece::new(0x0, Kind::Knight, Color::White), - Piece::new(0x0, Kind::Bishop, Color::White), - Piece::new(0x0, Kind::Rook, Color::White), - Piece::new(0x0, Kind::Queen, Color::White), - Piece::new(0x0, Kind::King, Color::White), + Piece::new(0x0, PieceType::Pawn, Color::White), + Piece::new(0x0, PieceType::Knight, Color::White), + Piece::new(0x0, PieceType::Bishop, Color::White), + Piece::new(0x0, PieceType::Rook, Color::White), + Piece::new(0x0, PieceType::Queen, Color::White), + Piece::new(0x0, PieceType::King, Color::White), ], black_pieces: [ - Piece::new(0x0, Kind::Pawn, Color::Black), - Piece::new(0x0, Kind::Knight, Color::Black), - Piece::new(0x0, Kind::Bishop, Color::Black), - Piece::new(0x0, Kind::Rook, Color::Black), - Piece::new(0x0, Kind::Queen, Color::Black), - Piece::new(0x0, Kind::King, Color::Black), + Piece::new(0x0, PieceType::Pawn, Color::Black), + Piece::new(0x0, PieceType::Knight, Color::Black), + Piece::new(0x0, PieceType::Bishop, Color::Black), + Piece::new(0x0, PieceType::Rook, Color::Black), + Piece::new(0x0, PieceType::Queen, Color::Black), + Piece::new(0x0, PieceType::King, Color::Black), ], state: State::new(), } @@ -84,27 +84,30 @@ impl Board { }; have_common_bit( - opponent[Kind::Pawn].bitboard, + opponent[PieceType::Pawn].bitboard, fetch_pawn_attacks(square, own_color), ) || have_common_bit( - opponent[Kind::Knight].bitboard, + opponent[PieceType::Knight].bitboard, fetch_knight_attacks(square), ) || have_common_bit( - opponent[Kind::Bishop].bitboard, + opponent[PieceType::Bishop].bitboard, fetch_bishop_attacks(all_occupancies, square), ) || have_common_bit( - opponent[Kind::Rook].bitboard, + opponent[PieceType::Rook].bitboard, fetch_rook_attacks(all_occupancies, square), ) || have_common_bit( - opponent[Kind::Queen].bitboard, + opponent[PieceType::Queen].bitboard, fetch_queen_attacks(all_occupancies, square), - ) || have_common_bit(opponent[Kind::King].bitboard, fetch_king_attacks(square)) + ) || have_common_bit( + opponent[PieceType::King].bitboard, + fetch_king_attacks(square), + ) } pub fn king_under_check(&self, color: Color) -> bool { let own_king_square = match color { - Color::White => lsb(self.white_pieces[Kind::King].bitboard), - Color::Black => lsb(self.black_pieces[Kind::King].bitboard), + Color::White => lsb(self.white_pieces[PieceType::King].bitboard), + Color::Black => lsb(self.black_pieces[PieceType::King].bitboard), }; self.is_attacked(own_king_square, Color::opponent_color(color)) @@ -112,50 +115,52 @@ impl Board { pub fn pseudo_moves_all(&self, color: Color) -> Vec { let mut moves = vec![]; - moves.extend(self.pseudo_moves(color, Kind::Pawn)); - moves.extend(self.pseudo_moves(color, Kind::Knight)); - moves.extend(self.pseudo_moves(color, Kind::Bishop)); - moves.extend(self.pseudo_moves(color, Kind::Rook)); - moves.extend(self.pseudo_moves(color, Kind::Queen)); - moves.extend(self.pseudo_moves(color, Kind::King)); + moves.extend(self.pseudo_moves(color, PieceType::Pawn)); + moves.extend(self.pseudo_moves(color, PieceType::Knight)); + moves.extend(self.pseudo_moves(color, PieceType::Bishop)); + moves.extend(self.pseudo_moves(color, PieceType::Rook)); + moves.extend(self.pseudo_moves(color, PieceType::Queen)); + moves.extend(self.pseudo_moves(color, PieceType::King)); moves } - pub fn pseudo_moves(&self, color: Color, kind: Kind) -> Vec { + pub fn pseudo_moves(&self, color: Color, piece_type: PieceType) -> Vec { let all_occupancies = self.all_occupancies(); let (pieces, opponent_occupancies, own_occupancies) = match color { Color::White => ( - self.white_pieces[kind].bitboard, + self.white_pieces[piece_type].bitboard, self.black_occupancies(), self.white_occupancies(), ), Color::Black => ( - self.black_pieces[kind].bitboard, + self.black_pieces[piece_type].bitboard, self.white_occupancies(), self.black_occupancies(), ), }; - match kind { - Kind::Pawn => pawn_pseudo_moves( + match piece_type { + PieceType::Pawn => pawn_pseudo_moves( pieces, all_occupancies, opponent_occupancies, self.state.en_passant_target_square(), color, ), - Kind::Knight => knight_pseudo_moves(pieces, all_occupancies, own_occupancies), - Kind::Bishop => bishop_pseudo_moves(pieces, all_occupancies, own_occupancies), - Kind::Rook => rook_pseudo_moves(pieces, all_occupancies, own_occupancies), - Kind::Queen => queen_pseudo_moves(pieces, all_occupancies, own_occupancies), - Kind::King => king_pseudo_moves(pieces, all_occupancies, own_occupancies, self, color), + PieceType::Knight => knight_pseudo_moves(pieces, all_occupancies, own_occupancies), + PieceType::Bishop => bishop_pseudo_moves(pieces, all_occupancies, own_occupancies), + PieceType::Rook => rook_pseudo_moves(pieces, all_occupancies, own_occupancies), + PieceType::Queen => queen_pseudo_moves(pieces, all_occupancies, own_occupancies), + PieceType::King => { + king_pseudo_moves(pieces, all_occupancies, own_occupancies, self, color) + } } } pub fn set_piece(&mut self, piece: Piece) { match piece.color { - Color::Black => self.black_pieces[piece.kind].bitboard |= piece.bitboard, - Color::White => self.white_pieces[piece.kind].bitboard |= piece.bitboard, + Color::Black => self.black_pieces[piece.piece_type].bitboard |= piece.bitboard, + Color::White => self.white_pieces[piece.piece_type].bitboard |= piece.bitboard, }; } @@ -173,22 +178,22 @@ impl Default for Board { #[derive(Debug, PartialEq, Eq, Clone)] pub struct Piece { pub bitboard: Bitboard, - pub kind: Kind, + pub piece_type: PieceType, pub color: Color, } impl Piece { - pub const fn new(bitboard: Bitboard, kind: Kind, color: Color) -> Self { + pub const fn new(bitboard: Bitboard, piece_type: PieceType, color: Color) -> Self { Self { bitboard, - kind, + piece_type, color, } } } #[derive(Debug, PartialEq, Eq, Clone, Copy)] -pub enum Kind { +pub enum PieceType { Pawn, Knight, Bishop, @@ -197,7 +202,7 @@ pub enum Kind { King, } -impl Kind { +impl PieceType { const fn idx(&self) -> usize { match self { Self::Pawn => 0, @@ -211,17 +216,17 @@ impl Kind { } use std::ops::{Index, IndexMut}; -impl Index for [Piece] { +impl Index for [Piece] { type Output = Piece; - fn index(&self, kind: Kind) -> &Self::Output { - &self[kind.idx()] + fn index(&self, piece_type: PieceType) -> &Self::Output { + &self[piece_type.idx()] } } -impl IndexMut for [Piece] { - fn index_mut(&mut self, kind: Kind) -> &mut Self::Output { - &mut self[kind.idx()] +impl IndexMut for [Piece] { + fn index_mut(&mut self, piece_type: PieceType) -> &mut Self::Output { + &mut self[piece_type.idx()] } } diff --git a/src/evaluation.rs b/src/evaluation.rs index 8a03298..ea283ef 100644 --- a/src/evaluation.rs +++ b/src/evaluation.rs @@ -2,18 +2,18 @@ use u64 as Bitboard; use crate::{ bitboard::lsb, - board::{Board, Color, Kind}, + board::{Board, Color, PieceType}, psqt::{mirror_index, piece_square_score}, }; -const fn piece_score(kind: Kind) -> i32 { - match kind { - Kind::Pawn => 100, - Kind::Knight => 320, - Kind::Bishop => 330, - Kind::Rook => 500, - Kind::Queen => 900, - Kind::King => 20000, +const fn piece_score(piece_type: PieceType) -> i32 { + match piece_type { + PieceType::Pawn => 100, + PieceType::Knight => 320, + PieceType::Bishop => 330, + PieceType::Rook => 500, + PieceType::Queen => 900, + PieceType::King => 20000, } } @@ -25,7 +25,7 @@ fn evaluate_side(board: &Board, color: Color) -> i32 { }; for piece in pieces { - let (kind, mut bitboard): (Kind, Bitboard) = (piece.kind, piece.bitboard); + let (piece_type, mut bitboard): (PieceType, Bitboard) = (piece.piece_type, piece.bitboard); let mut score = 0; while bitboard != 0 { let psqt_index = match color { @@ -33,8 +33,8 @@ fn evaluate_side(board: &Board, color: Color) -> i32 { Color::Black => mirror_index(lsb(bitboard)), }; - score += piece_score(kind); - score += piece_square_score(kind, psqt_index); + score += piece_score(piece_type); + score += piece_square_score(piece_type, psqt_index); bitboard &= bitboard - 1; } total_score += score; @@ -56,7 +56,7 @@ pub fn evaluate_position(board: &Board, color: Color) -> i32 { #[cfg(test)] mod tests { use crate::{ - board::{Color, Kind}, + board::{Color, PieceType}, evaluation::{evaluate_position, evaluate_side, piece_score}, fen::from_fen, }; @@ -68,12 +68,12 @@ mod tests { #[test] fn test_piece_score() -> Result<(), String> { - assert_eq!(100, piece_score(Kind::Pawn)); - assert_eq!(320, piece_score(Kind::Knight)); - assert_eq!(330, piece_score(Kind::Bishop)); - assert_eq!(500, piece_score(Kind::Rook)); - assert_eq!(900, piece_score(Kind::Queen)); - assert_eq!(20000, piece_score(Kind::King)); + assert_eq!(100, piece_score(PieceType::Pawn)); + assert_eq!(320, piece_score(PieceType::Knight)); + assert_eq!(330, piece_score(PieceType::Bishop)); + assert_eq!(500, piece_score(PieceType::Rook)); + assert_eq!(900, piece_score(PieceType::Queen)); + assert_eq!(20000, piece_score(PieceType::King)); Ok(()) } diff --git a/src/fen.rs b/src/fen.rs index 325e541..1a51a8c 100644 --- a/src/fen.rs +++ b/src/fen.rs @@ -1,4 +1,4 @@ -use crate::board::{Board, Color, Kind, Piece}; +use crate::board::{Board, Color, Piece, PieceType}; use crate::game::Game; use crate::state::{Castle, State}; use String as FenError; @@ -40,13 +40,13 @@ pub fn piece_placement(pieces: &str) -> Result { Color::White }; - if let Some(kind) = match c.to_ascii_lowercase() { - 'r' => Some(Kind::Rook), - 'n' => Some(Kind::Knight), - 'b' => Some(Kind::Bishop), - 'q' => Some(Kind::Queen), - 'k' => Some(Kind::King), - 'p' => Some(Kind::Pawn), + if let Some(piece_type) = match c.to_ascii_lowercase() { + 'r' => Some(PieceType::Rook), + 'n' => Some(PieceType::Knight), + 'b' => Some(PieceType::Bishop), + 'q' => Some(PieceType::Queen), + 'k' => Some(PieceType::King), + 'p' => Some(PieceType::Pawn), '/' => { file = 0; rank = rank.saturating_sub(1); @@ -62,7 +62,7 @@ pub fn piece_placement(pieces: &str) -> Result { )) } } { - board.set_piece(Piece::new(1 << square, kind, color)); + board.set_piece(Piece::new(1 << square, piece_type, color)); file += 1; }; } diff --git a/src/move.rs b/src/move.rs index 40c46e6..eacc202 100644 --- a/src/move.rs +++ b/src/move.rs @@ -2,7 +2,7 @@ use core::fmt; use crate::{ bitboard::{have_common_bit, square_to_bitboard}, - board::{Board, Color, Kind, Piece}, + board::{Board, Color, Piece, PieceType}, square::{coords_to_square, square_to_algebraic, Square}, state::{Castle, State}, }; @@ -112,6 +112,8 @@ impl Board { self.update_board_state(mv, color); } + pub fn unmake_move(&mut self) {} + pub fn update_board_state(&mut self, mv: &Move, color: Color) { let (own_pieces, opponent_pieces, en_passant_square) = match color { Color::White => ( @@ -125,7 +127,7 @@ impl Board { Some(mv.src - 8), ), }; - let pawn_move = Self::is_pawn_move(mv.src, &own_pieces[Kind::Pawn]); + let pawn_move = Self::is_pawn_move(mv.src, &own_pieces[PieceType::Pawn]); Self::update_game_state(&mut self.state, mv, color, pawn_move); @@ -193,10 +195,10 @@ impl Board { fn promote_piece(square: usize, pieces: &mut [Piece; 6], promote: &Promote) { match promote { - Promote::Knight => pieces[Kind::Knight].bitboard |= square_to_bitboard(square), - Promote::Bishop => pieces[Kind::Bishop].bitboard |= square_to_bitboard(square), - Promote::Rook => pieces[Kind::Rook].bitboard |= square_to_bitboard(square), - Promote::Queen => pieces[Kind::Queen].bitboard |= square_to_bitboard(square), + Promote::Knight => pieces[PieceType::Knight].bitboard |= square_to_bitboard(square), + Promote::Bishop => pieces[PieceType::Bishop].bitboard |= square_to_bitboard(square), + Promote::Rook => pieces[PieceType::Rook].bitboard |= square_to_bitboard(square), + Promote::Queen => pieces[PieceType::Queen].bitboard |= square_to_bitboard(square), }; } diff --git a/src/movegen.rs b/src/movegen.rs index c9c094a..cc9dcf1 100644 --- a/src/movegen.rs +++ b/src/movegen.rs @@ -402,7 +402,7 @@ mod tests { use crate::{attack::init_attacks, fen::from_fen}; use super::*; - use crate::board::Kind; + use crate::board::PieceType; const FEN_PAWN_MOVES: &str = "r1bqk2r/p4pbp/1pnp1np1/P3P1B1/3NNP2/8/1PP3PP/R2QKB1R w - - 0 1"; @@ -427,7 +427,7 @@ mod tests { Move::new_with_type(36, 45, MoveType::Capture), ]; - let mut actual = new_game.board.pseudo_moves(Color::White, Kind::Pawn); + let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Pawn); actual.sort(); assert_eq!(expected, actual); @@ -440,7 +440,7 @@ mod tests { Move::new_with_type(55, 39, MoveType::DoublePush), Move::new(55, 47), ]; - let mut actual = new_game.board.pseudo_moves(Color::Black, Kind::Pawn); + let mut actual = new_game.board.pseudo_moves(Color::Black, PieceType::Pawn); actual.sort(); assert_eq!(expected, actual); @@ -463,7 +463,7 @@ mod tests { Move::new(21, 36), Move::new_with_type(21, 38, MoveType::Capture), ]; - let mut actual = new_game.board.pseudo_moves(Color::White, Kind::Knight); + let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Knight); actual.sort(); assert_eq!(expected, actual); @@ -486,7 +486,7 @@ mod tests { Move::new(26, 44), Move::new_with_type(26, 53, MoveType::Capture), ]; - let mut actual = new_game.board.pseudo_moves(Color::White, Kind::Bishop); + let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Bishop); actual.sort(); assert_eq!(expected, actual); @@ -514,7 +514,7 @@ mod tests { Move::new(12, 36), Move::new_with_type(12, 44, MoveType::Capture), ]; - let mut actual = new_game.board.pseudo_moves(Color::White, Kind::Rook); + let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Rook); actual.sort(); assert_eq!(expected, actual); @@ -537,7 +537,7 @@ mod tests { Move::new(17, 41), Move::new_with_type(17, 49, MoveType::Capture), ]; - let mut actual = new_game.board.pseudo_moves(Color::White, Kind::Queen); + let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Queen); actual.sort(); assert_eq!(expected, actual); @@ -563,13 +563,13 @@ mod tests { Move::new(22, 29), Move::new(22, 30), ]; - let mut actual = new_game.board.pseudo_moves(Color::White, Kind::King); + let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::King); actual.sort(); assert_eq!(expected, actual); let new_game_2 = from_fen(FEN_KING_MOVES[1])?; let expected = vec![Move::new_with_type(4, 2, MoveType::Castle), Move::new(4, 3)]; - let mut actual = new_game_2.board.pseudo_moves(Color::White, Kind::King); + let mut actual = new_game_2.board.pseudo_moves(Color::White, PieceType::King); actual.sort(); assert_eq!(expected, actual); @@ -581,7 +581,7 @@ mod tests { Move::new(60, 61), Move::new_with_type(60, 62, MoveType::Castle), ]; - let mut actual = new_game_3.board.pseudo_moves(Color::Black, Kind::King); + let mut actual = new_game_3.board.pseudo_moves(Color::Black, PieceType::King); actual.sort(); assert_eq!(expected, actual); diff --git a/src/psqt.rs b/src/psqt.rs index 1eac735..1ba2534 100644 --- a/src/psqt.rs +++ b/src/psqt.rs @@ -1,24 +1,24 @@ -use crate::board::Kind; +use crate::board::PieceType; -pub const fn piece_square_score(kind: Kind, index: usize) -> i32 { - match kind { - Kind::Pawn => PAWN_PSQT[index], - Kind::Knight => KNIGHT_PSQT[index], - Kind::Bishop => BISHOP_PSQT[index], - Kind::Rook => ROOK_PSQT[index], - Kind::Queen => QUEEN_PSQT[index], - Kind::King => KING_MIDGAME_PSQT[index], +pub const fn piece_square_score(piece_type: PieceType, index: usize) -> i32 { + match piece_type { + PieceType::Pawn => PAWN_PSQT[index], + PieceType::Knight => KNIGHT_PSQT[index], + PieceType::Bishop => BISHOP_PSQT[index], + PieceType::Rook => ROOK_PSQT[index], + PieceType::Queen => QUEEN_PSQT[index], + PieceType::King => KING_MIDGAME_PSQT[index], } } -pub const fn piece_square_score_endgame(kind: Kind, index: usize) -> i32 { - match kind { - Kind::Pawn => PAWN_PSQT[index], - Kind::Knight => KNIGHT_PSQT[index], - Kind::Bishop => BISHOP_PSQT[index], - Kind::Rook => ROOK_PSQT[index], - Kind::Queen => QUEEN_PSQT[index], - Kind::King => KING_ENDGAME_PSQT[index], +pub const fn piece_square_score_endgame(piece_type: PieceType, index: usize) -> i32 { + match piece_type { + PieceType::Pawn => PAWN_PSQT[index], + PieceType::Knight => KNIGHT_PSQT[index], + PieceType::Bishop => BISHOP_PSQT[index], + PieceType::Rook => ROOK_PSQT[index], + PieceType::Queen => QUEEN_PSQT[index], + PieceType::King => KING_ENDGAME_PSQT[index], } } @@ -113,19 +113,19 @@ const KING_ENDGAME_PSQT: [i32; 64] = [ #[cfg(test)] mod tests { use crate::{ - board::Kind, + board::PieceType, psqt::{mirror_index, piece_square_score}, square::Square, }; #[test] fn test_piece_square_score() -> Result<(), String> { - assert_eq!(50, piece_square_score(Kind::Pawn, Square::A7)); - assert_eq!(-40, piece_square_score(Kind::Knight, Square::B1)); - assert_eq!(0, piece_square_score(Kind::Bishop, Square::D2)); - assert_eq!(-5, piece_square_score(Kind::Rook, Square::A2)); - assert_eq!(5, piece_square_score(Kind::Queen, Square::D3)); - assert_eq!(30, piece_square_score(Kind::King, Square::G1)); + assert_eq!(50, piece_square_score(PieceType::Pawn, Square::A7)); + assert_eq!(-40, piece_square_score(PieceType::Knight, Square::B1)); + assert_eq!(0, piece_square_score(PieceType::Bishop, Square::D2)); + assert_eq!(-5, piece_square_score(PieceType::Rook, Square::A2)); + assert_eq!(5, piece_square_score(PieceType::Queen, Square::D3)); + assert_eq!(30, piece_square_score(PieceType::King, Square::G1)); Ok(()) }