Merge pull request #15 from eboatwright/dev

v3.0.8

Author: eboatwright

Cargo.toml

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

README.md

@@ -5,13 +5,19 @@
  [Play against Maxwell on Lichess!](https://lichess.org/@/MaxwellOnLC) | [Some of Maxwell's Games](https://www.chess.com/library/collections/maxwells-games-my-chess-engine-2FFU82NM4)
 
 ## Features
+#### Parameters
+ - fen=\<FEN STRING>: Sets up the board by a fen string (Doesn't work for UCI games) (default=STARTING_FEN)
+ - debug=\<BOOLEAN>: Toggle debug output that gets outputed per ply (default=true)
+ - opening_book=\<BOOLEAN>: Toggle opening book (default=true)
+ - time_management=\<BOOLEAN>: Toggle time management, if false the bot will use all the remaining time (default=true)
 #### UCI Interface
  - Only supports games from startpos
  - uci, isready, ucinewgame, position, go, stop, and quit commands
 #### Board Representation
  - Purely bitboards
  - Supports loading from FEN strings
 #### Move Generation
+ - Basic handcrafted opening book
  - Magic bitboards for sliding pieces
  - Hardcoded pawn movement
  - Bitboard masks for other pieces calculated at startup
@@ -23,7 +29,7 @@
  - Attacked squares around kings
 #### Move Ordering
  - Hash move / best move from previous iteration
- - Capturing a piece of higher value
+ - MVV-LVA
  - 2 Killer moves
  - History heuristic
  - Castling
@@ -33,11 +39,14 @@
  - Iterative deepening
  - Aspiration windows
    - Starts at 40 and multiplies by 4 if out of alpha beta bounds
- - Time management: if less than 7 moves have been played, it uses 2.5% of it's remaining time, otherwise 7%
+ - Time management
+   - If less than 7 moves have been played, it uses 2.5% of it's remaining time, otherwise 7%
+   - This value is then also clamped between 0.25 and 20.0 seconds
  - Exits search if a mate is found within search depth
  - Alpha beta pruning
  - Quiescence search
- - Transposition table: No set max size, but moves get removed after 10 moves
+ - Transposition table
+   - No set max size, but entries get removed after 10 moves without hits
  - Null move pruning
  - Razoring
  - Reverse futility pruning

src/bot.rs

@@ -1,6 +1,6 @@
-use crate::piece_square_tables::QUEEN_WORTH;
-use crate::PAWN;
-use crate::NO_PIECE;
+use crate::STARTING_FEN;
+use crate::piece_square_tables::{PAWN_WORTH, QUEEN_WORTH};
+use crate::pieces::{PAWN, PROMOTABLE, NO_PIECE};
 use crate::utils::{CHECKMATE_EVAL, evaluation_is_mate, moves_ply_from_mate};
 use std::time::Instant;
 use crate::move_sorter::MoveSorter;
@@ -11,15 +11,54 @@ use crate::Board;
 
 pub const MAX_SEARCH_EXTENSIONS: u8 = 16;
 pub const FUTILITY_PRUNING_THESHOLD_PER_PLY: i32 = 60;
+pub const RAZORING_THRESHOLD_PER_PLY: i32 = 300;
+
+pub const PERCENT_OF_TIME_TO_USE_BEFORE_6_FULL_MOVES: f32 = 0.025; // 2.5%
+pub const PERCENT_OF_TIME_TO_USE_AFTER_6_FULL_MOVES: f32 = 0.07; // 7%
+
+pub const MIN_TIME_PER_MOVE: f32 = 0.25; // seconds
+pub const MAX_TIME_PER_MOVE: f32 = 20.0;
+
+#[derive(Clone, Debug)]
+pub struct BotConfig {
+	pub fen: String,
+	pub debug_output: bool,
+	pub opening_book: bool,
+	pub time_management: bool,
+}
+
+impl BotConfig {
+	pub fn from_args(args: Vec<String>) -> Self {
+		let _true = "true".to_string();
+		Self { // This is so ugly lol
+			fen: Self::get_arg_value(&args, "fen").unwrap_or(STARTING_FEN.to_string()),
+			debug_output: Self::get_arg_value(&args, "debug_output").unwrap_or(_true.clone()) == _true,
+			opening_book: Self::get_arg_value(&args, "opening_book").unwrap_or(_true.clone()) == _true,
+			time_management: Self::get_arg_value(&args, "time_management").unwrap_or(_true.clone()) == _true,
+		}
+	}
+
+	fn get_arg_value(args: &Vec<String>, key: &'static str) -> Option<String> {
+		for arg in args.iter() {
+			if arg.contains(key) {
+				return Some(arg[key.len() + 1..].to_string());
+			}
+		}
+
+		None
+	}
+}
 
 pub struct Bot {
+	pub config: BotConfig,
+
 	time_to_think: f32,
 	think_timer: Instant,
 	pub search_cancelled: bool,
 	searched_one_move: bool,
 
 	opening_book: OpeningBook,
-	in_opening: bool,
+	in_opening_book: bool,
 
 	move_sorter: MoveSorter,
 	pub transposition_table: TranspositionTable,
@@ -37,15 +76,19 @@ pub struct Bot {
 }
 
 impl Bot {
-	pub fn new(in_opening: bool) -> Self {
+	pub fn new(config: BotConfig) -> Self {
+		let in_opening_book = config.opening_book;
+
 		Self {
+			config,
+
 			time_to_think: 0.0,
 			think_timer: Instant::now(),
 			search_cancelled: false,
 			searched_one_move: false,
 
 			opening_book: OpeningBook::create(),
-			in_opening,
+			in_opening_book,
 
 			move_sorter: MoveSorter::new(),
 			transposition_table: TranspositionTable::empty(),
@@ -63,24 +106,34 @@ impl Bot {
 		}
 	}
 
+	pub fn println(&self, output: String) {
+		if self.config.debug_output {
+			println!("{}", output);
+		}
+	}
+
 	pub fn start(&mut self, board: &mut Board, moves: String, my_time: f32) {
-		if self.in_opening {
+		if self.in_opening_book {
 			let opening_move = self.opening_book.get_opening_move(moves);
 			if opening_move == NULL_MOVE {
-				self.in_opening = false;
+				self.in_opening_book = false;
 			} else {
 				self.best_move = opening_move;
 				return;
 			}
 		}
 
-		let time_percentage = if board.moves.len() / 2 <= 6 {
-			0.025
+		self.time_to_think = if self.config.time_management {
+			let time_percentage = if board.moves.len() / 2 <= 6 {
+				PERCENT_OF_TIME_TO_USE_BEFORE_6_FULL_MOVES
+			} else {
+				PERCENT_OF_TIME_TO_USE_AFTER_6_FULL_MOVES
+			};
+
+			(my_time * time_percentage).clamp(MIN_TIME_PER_MOVE, MAX_TIME_PER_MOVE)
 		} else {
-			0.07
+			my_time
 		};
-		self.time_to_think = (my_time * time_percentage).clamp(0.25, 20.0);
-		// self.time_to_think = my_time;
 
 		self.search_cancelled = false;
 
@@ -123,7 +176,7 @@ impl Bot {
 				self.evaluation = self.evaluation_this_iteration;
 			}
 
-			println!("Depth: {}, Window: {}, Evaluation: {}, Best move: {}, Positions searched: {} + Quiescence positions searched: {} = {}, Transposition Hits: {}",
+			self.println(format!("Depth: {}, Window: {}, Evaluation: {}, Best move: {}, Positions searched: {} + Quiescence positions searched: {} = {}, Transposition Hits: {}",
 				depth,
 				window,
 				self.evaluation * board.perspective(),
@@ -132,24 +185,26 @@ impl Bot {
 				self.quiescence_searched,
 				self.positions_searched + self.quiescence_searched,
 				self.transposition_hits,
-			);
+			));
 
 			if evaluation_is_mate(self.evaluation) {
 				let moves_until_mate = moves_ply_from_mate(self.evaluation);
 				if moves_until_mate <= depth {
-					println!("Mate found in {}", (moves_until_mate as f32 * 0.5).ceil());
+					self.println(format!("Mate found in {}", (moves_until_mate as f32 * 0.5).ceil()));
 					break;
 				}
 			}
 
 			if self.search_cancelled {
-				println!("Search cancelled");
+				self.println("Search cancelled".to_string());
 				break;
 			}
 		}
 
 		self.transposition_table.update();
-		self.transposition_table.print_size();
+		if self.config.debug_output {
+			self.transposition_table.print_size();
+		}
 	}
 
 	fn should_cancel_search(&mut self) -> bool {
@@ -199,11 +254,12 @@ impl Bot {
 		if !is_pv
 		&& depth > 0
 		&& depth_left > 0
+		&& board.get_last_move().capture == NO_PIECE as u8
 		&& !board.king_in_check(board.white_to_move) {
 			// Null Move Pruning
 			if depth_left >= 3
 			&& board.try_null_move() {
-				// let reduction = 3 - (depth_left - 3) / 2;
+				// let reduction = 3 - (depth_left - 3) / 2; // This didn't work at all lol
 				let evaluation = -self.alpha_beta_search(board, depth + 1, depth_left - 3, -beta, -beta + 1, number_of_extensions);
 
 				board.undo_null_move();
@@ -217,14 +273,13 @@ impl Bot {
 
 			// Reverse Futility Pruning
 			if depth_left <= 4
-			&& static_eval - (FUTILITY_PRUNING_THESHOLD_PER_PLY * depth_left as i32) >= beta {
+			&& static_eval - FUTILITY_PRUNING_THESHOLD_PER_PLY * (depth_left as i32) >= beta {
 				return static_eval;
 			}
 
 			// Razoring
 			if depth_left <= 3
-			&& board.get_last_move().capture == NO_PIECE as u8
-			&& static_eval + QUEEN_WORTH < alpha {
+			&& static_eval + RAZORING_THRESHOLD_PER_PLY * (depth_left as i32) < alpha {
 				depth_left -= 1;
 			}
 		}
@@ -357,6 +412,18 @@ impl Bot {
 		let sorted_moves = self.move_sorter.sort_moves(board, legal_moves, NULL_MOVE, u8::MAX);
 
 		for m in sorted_moves {
+			// Delta Pruning
+			if !board.king_in_check(board.white_to_move) {
+				let mut threshold = QUEEN_WORTH;
+				if PROMOTABLE.contains(&m.flag) {
+					threshold += QUEEN_WORTH - PAWN_WORTH;
+				}
+
+				if evaluation < alpha - threshold {
+					continue;
+				}
+			}
+
 			board.make_move(m);
 			let evaluation = -self.quiescence_search(board, -beta, -alpha);
 			board.undo_last_move();

src/main.rs

@@ -13,9 +13,8 @@ Random ideas to try (from other engines and chessprogramming.org)
 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/Triangular_PV-Table
-https://www.chessprogramming.org/Razoring (look into a better implementation)
+https://www.chessprogramming.org/Static_Exchange_Evaluation
 
 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 ;))
@@ -48,7 +47,7 @@ mod bot;
 mod move_sorter;
 
 use crate::castling_rights::print_castling_rights;
-use crate::bot::Bot;
+use crate::bot::{Bot, BotConfig};
 use crate::perft::*;
 use crate::move_data::MoveData;
 use crate::pieces::*;
@@ -68,10 +67,12 @@ pub const ENDGAME_POSITION:  &str = "8/pk4p1/2prp3/3p1p2/3P2p1/R2BP3/2P2KPP/8 w
 pub const PAWN_EVAL_TESTING: &str = "4k3/p1pp4/8/4pp1P/2P4P/8/P5P1/4K3 w - - 0 1";
 
 fn main() {
-	let mut log = Log::none();
+	let bot_config = BotConfig::from_args(std::env::args().collect::<Vec<String>>());
 
-	let mut board = Board::from_fen(STARTING_FEN);
-	let mut bot = Bot::new(true);
+	// let mut log = Log::none();
+
+	let mut board = Board::from_fen(&bot_config.fen);
+	let mut bot = Bot::new(bot_config.clone());
 
 	let mut command = String::new();
 	let mut moves = String::new();
@@ -98,7 +99,7 @@ fn main() {
 			"ucinewgame" => {
 				// log = Log::new();
 				board = Board::from_fen(STARTING_FEN);
-				bot = Bot::new(true);
+				bot = Bot::new(bot_config.clone());
 			}
 
 			// Format: position startpos (moves e2e4 e7e5 ...)
@@ -114,7 +115,7 @@ fn main() {
 					if !board.play_move(data) {
 						let err = format!("{}: failed to play move: {}", "FATAL ERROR".white().on_red(), coordinates);
 						println!("{}", err);
-						log.write(err);
+						// log.write(err);
 					}
 				}
 				moves.pop();
@@ -189,33 +190,25 @@ fn main() {
 			}
 
 			// "test" => {
-			// 	let mut board = Board::from_fen(STARTING_FEN);
-
 			// 	let mut old_best_time  =  f32::MAX;
 			// 	let mut old_worst_time = -f32::MAX;
 
 			// 	let mut new_best_time  =  f32::MAX;
 			// 	let mut new_worst_time = -f32::MAX;
 
-			// 	for _ in 0..5 {
-			// 		board.clear_castling_rights();
-			// 		board.zobrist.clear();
+			// 	let piece = BLACK_ROOK as u8;
+			// 	let capture = WHITE_KNIGHT as u8;
 
+			// 	for _ in 0..5 {
 			// 		let timer = Instant::now();
-			// 		for _ in 0..100_000 {
-			// 			let legal_moves = board.get_legal_moves_for_color(board.white_to_move, false);
-			// 			let _ = sort_moves(&board, legal_moves, None);
+			// 		for _ in 0..1_000_000_000 {
+			// 			let score = MVV_LVA[get_piece_type(piece as usize) * 6 + get_piece_type(capture as usize)];
 			// 		}
 			// 		let old_time = timer.elapsed().as_secs_f32();
 
-
-			// 		board.clear_castling_rights();
-			// 		board.zobrist.clear();
-
 			// 		let timer = Instant::now();
-			// 		for _ in 0..100_000 {
-			// 			let legal_moves = board.get_legal_moves_for_color(board.white_to_move, false);
-			// 			let _ = new_sort_moves(&board, legal_moves, None);
+			// 		for _ in 0..1_000_000_000 {
+			// 			let score = (5 - get_piece_type(piece as usize)) + (get_piece_type(capture as usize) + 1) * 10;
 			// 		}
 			// 		let new_time = timer.elapsed().as_secs_f32();
 
@@ -241,7 +234,8 @@ fn main() {
 			// 	println!("New: worst: {}, best: {}", new_worst_time, new_best_time);
 			// }
 
-			_ => log.write(format!("Unknown command: {}", command)),
+			// _ => log.write(format!("Unknown command: {}", command)),
+			_ => {}
 		}
 	}
 }