Merge pull request #13 from eboatwright/dev

v3.0.7

Author: eboatwright

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "maxwell"
-version = "3.0.5"
+version = "3.0.7"
 edition = "2021"
 
 [dependencies]

README.md

@@ -28,7 +28,6 @@
  - History heuristic
  - Castling
  - Promotions
- - Boost for moving a piece to a square a friendly piece attacks
  - Penalty for moving a piece to a square an opponent's piece attacks
 #### Search
  - Iterative deepening

src/board.rs

@@ -436,7 +436,7 @@ impl Board {
 
 	pub fn king_in_check(&mut self, king_is_white: bool) -> bool {
 		self.calculate_attacked_squares_for_color((!king_is_white) as usize);
-		self.piece_bitboards[if king_is_white { WHITE_KING } else { BLACK_KING }] & self.attacked_squares_bitboards[(!king_is_white) as usize] != 0
+		self.piece_bitboards[build_piece(king_is_white, KING)] & self.attacked_squares_bitboards[(!king_is_white) as usize] != 0
 	}
 
 	pub fn get_legal_moves_for_color(&mut self, white_pieces: bool, only_captures: bool) -> Vec<MoveData> {

src/bot.rs

@@ -33,7 +33,6 @@ pub struct Bot {
 	positions_searched: u128,
 	quiescence_searched: u128,
 	transposition_hits: u128,
-	null_move_prunes: u128,
 }
 
 impl Bot {
@@ -60,7 +59,6 @@ impl Bot {
 			positions_searched: 0,
 			quiescence_searched: 0,
 			transposition_hits: 0,
-			null_move_prunes: 0,
 		}
 	}
 
@@ -93,18 +91,18 @@ impl Bot {
 		self.positions_searched = 0;
 		self.quiescence_searched = 0;
 		self.transposition_hits = 0;
-		self.null_move_prunes = 0;
 
 		self.move_sorter.clear();
 
+		let mut window = 40;
+
 		self.think_timer = Instant::now();
 		for depth in 1..=(255 - MAX_SEARCH_EXTENSIONS) {
 			self.searched_one_move = false;
 			self.best_move_this_iteration = NULL_MOVE;
 			self.evaluation_this_iteration = 0;
 
 
-			let mut window = 40;
 			loop {
 				let (alpha, beta) = (last_evaluation - window, last_evaluation + window);
 
@@ -124,7 +122,7 @@ impl Bot {
 				self.evaluation = self.evaluation_this_iteration;
 			}
 
-			println!("Depth: {}, Window: {}, Evaluation: {}, Best move: {}, Positions searched: {}, Quiescence positions searched: {}, Total: {}, Transposition Hits: {}, Null move prunes: {}",
+			println!("Depth: {}, Window: {}, Evaluation: {}, Best move: {}, Positions searched: {} + Quiescence positions searched: {} = {}, Transposition Hits: {}",
 				depth,
 				window,
 				self.evaluation * board.perspective(),
@@ -133,7 +131,6 @@ impl Bot {
 				self.quiescence_searched,
 				self.positions_searched + self.quiescence_searched,
 				self.transposition_hits,
-				self.null_move_prunes,
 			);
 
 			if evaluation_is_mate(self.evaluation) {
@@ -196,37 +193,45 @@ impl Bot {
 			return data.evaluation;
 		}
 
-		// Razoring
-		if depth_left == 3
+		let is_pv = alpha != beta - 1;
+
+		if !is_pv
 		&& depth > 0
-		&& board.get_last_move().capture == NO_PIECE as u8
+		&& depth_left > 0
 		&& !board.king_in_check(board.white_to_move) {
-			let evaluation = board.evaluate();
-			if evaluation + QUEEN_WORTH < alpha {
-				depth_left -= 1;
-			}
-		}
+			// Null Move Pruning
+			if depth_left >= 3
+			&& board.try_null_move() {
+				// let reduction = 3 - (depth_left - 3) / 2;
+				let evaluation = -self.alpha_beta_search(board, depth + 1, depth_left - 3, -beta, -beta + 1, number_of_extensions);
 
-		if depth_left == 0 {
-			return self.quiescence_search(board, alpha, beta);
-		}
+				board.undo_null_move();
 
-		let is_pv = alpha != beta - 1;
+				if evaluation >= beta {
+					return evaluation;
+				}
+			}
 
-		if !is_pv
-		&& depth > 0
-		&& depth_left >= 3
-		&& board.try_null_move() {
-			let evaluation = -self.alpha_beta_search(board, depth + 1, depth_left - 3, -beta, -beta + 1, number_of_extensions);
+			let static_eval = board.evaluate();
 
-			board.undo_null_move();
+			// Reverse Futility Pruning
+			if depth_left <= 4
+			&& static_eval - (70 * depth_left as i32) >= beta {
+				return static_eval;
+			}
 
-			if evaluation >= beta {
-				self.null_move_prunes += 1;
-				return evaluation;
+			// Razoring
+			if depth_left <= 3
+			&& board.get_last_move().capture == NO_PIECE as u8
+			&& static_eval + QUEEN_WORTH < alpha {
+				depth_left -= 1;
 			}
 		}
 
+		if depth_left == 0 {
+			return self.quiescence_search(board, alpha, beta);
+		}
+
 		let mut best_move_this_search = NULL_MOVE;
 		let mut node_type = NodeType::UpperBound;
 
@@ -270,6 +275,7 @@ impl Bot {
 
 
 
+			// Late Move Reduction / (Kind of) Principal Variation Search
 			let mut evaluation = 0;
 			let mut needs_full_search = true;
 
@@ -346,7 +352,9 @@ impl Bot {
 			return evaluation;
 		}
 
-		let sorted_moves = self.move_sorter.sort_moves(board, legal_moves, NULL_MOVE, 0);
+		// Depth is set to u8::MAX because it's only used for killer moves, and we don't need that here
+		let sorted_moves = self.move_sorter.sort_moves(board, legal_moves, NULL_MOVE, u8::MAX);
+
 		for m in sorted_moves {
 			board.make_move(m);
 			let evaluation = -self.quiescence_search(board, -beta, -alpha);

src/main.rs

@@ -1,33 +1,27 @@
 /* TODO
-try to stop Bot from getting it's queen kicked around
 calculate my own magic numbers; currently "borrowing" Sebastian Lague's ^^
-check out pin detection for checks?
+check out pin detection to speed up check detection?
 try to write a neural network to evaluate positions? :o
+figure out how to implement "pondering" to think on opponent's time
 
-Ideas I've tried but they made no impact (Or I implemented them wrong :P)
+Ideas I've tried, but they didn't help, or made it play worse (Or I implemented them wrong :P)
 https://www.chessprogramming.org/Futility_Pruning
-https://www.chessprogramming.org/Reverse_Futility_Pruning
 https://www.chessprogramming.org/Principal_Variation_Search
+https://www.chessprogramming.org/Internal_Iterative_Deepening
 
 Random ideas to try (from other engines and chessprogramming.org)
-History reduction?
+History reduction
 https://www.chessprogramming.org/History_Leaf_Pruning
 https://www.chessprogramming.org/Futility_Pruning#MoveCountBasedPruning
 https://www.chessprogramming.org/Delta_Pruning
-https://www.chessprogramming.org/Internal_Iterative_Deepening
 https://www.chessprogramming.org/Triangular_PV-Table
 https://www.chessprogramming.org/Razoring (look into a better implementation)
 
 Some random resources I found:
 https://analog-hors.github.io/site/magic-bitboards/ (didn't use this for my initial implementation, but that might change ;))
 https://web.archive.org/web/20071030220825/http://www.brucemo.com/compchess/programming/pvs.htm
-https://github.com/lynx-chess/Lynx
+https://github.com/lynx-chess/Lynx/
 https://github.com/Heiaha/Weiawaga/
-
-v3.0.5 vs v3.0.4
-v1: 10 - 15 - (11 draws)
-v2: 12 - 14 - (10 draws)
-current: 13 - 9 - (14 draws)
 */
 
 #![allow(dead_code)]

src/move_sorter.rs

@@ -40,10 +40,10 @@ impl MoveSorter {
 
 		let endgame = board.endgame_multiplier();
 
-		// Mental note that this is here
-		board.calculate_attacked_squares();
+		// board.calculate_attacked_squares();
+		board.calculate_attacked_squares_for_color((!board.white_to_move) as usize);
 
-		let squares_i_attack = board.attacked_squares_bitboards[board.white_to_move as usize];
+		// let squares_i_attack = board.attacked_squares_bitboards[board.white_to_move as usize];
 		let squares_opponent_attacks = board.attacked_squares_bitboards[!board.white_to_move as usize];
 
 		for i in 0..num_of_moves {
@@ -70,9 +70,9 @@ impl MoveSorter {
 					score += 2000;
 				}
 
-				if squares_i_attack & (1 << m.to) != 0 {
-					score += get_full_worth_of_piece(m.piece as usize, m.to as usize, endgame);
-				}
+				// if squares_i_attack & (1 << m.to) != 0 {
+				// 	score += get_full_worth_of_piece(m.piece as usize, m.to as usize, endgame);
+				// }
 
 				if squares_opponent_attacks & (1 << m.to) != 0 {
 					score -= 2 * get_full_worth_of_piece(m.piece as usize, m.to as usize, endgame);

src/opening_book.rs

@@ -43,6 +43,8 @@ impl OpeningBook {
 
 				"Xc2c4 e7e5 b1c3 g8f6",
 				"e2e4 c7c5 Xb1c3 b8c6 f1b5 c6d4 b5c4 a7a6 g1f3 b7b5 c4e2 c8b7 e1g1 e7e6 d2d3 d4e2 d1e2",
+
+				"e2e4 Xg7g6 d2d4 f8g7 b1c3 d7d6 c1e3",
 			],
 		}
 	}