From 9609e96807a44bff2d261d362d2b14814c035925 Mon Sep 17 00:00:00 2001 From: Oriol Arcas Date: Tue, 16 Jan 2024 14:50:37 +0100 Subject: [PATCH 1/3] Apply clippy to all the source --- chusst-gen/src/board.rs | 11 +- chusst-gen/src/board/bitboards.rs | 8 +- chusst-gen/src/board/bitboards/in_between.rs | 19 ++- chusst-gen/src/board/simple.rs | 2 +- chusst-gen/src/eval.rs | 65 ++++------ chusst-gen/src/eval/check.rs | 82 ++++++------ chusst-gen/src/eval/conditions.rs | 4 +- chusst-gen/src/eval/feedback.rs | 16 +-- chusst-gen/src/eval/iter.rs | 130 +++++++++---------- chusst-gen/src/eval/play.rs | 11 +- chusst-gen/src/eval/tests.rs | 15 +-- chusst-gen/src/game.rs | 7 +- chusst-uci/src/engine.rs | 4 +- chusst-uci/src/main.rs | 31 ++--- chusst-uci/src/stdin.rs | 4 +- pgn2yaml/src/converter.rs | 8 +- pgn2yaml/src/converter/interpreter.rs | 11 +- pgn2yaml/src/converter/serializer.rs | 2 +- pgn2yaml/src/main.rs | 2 +- pgn2yaml/src/reader.rs | 4 +- pgn2yaml/src/reader/parser.rs | 14 +- src-tauri/src/main.rs | 7 +- 22 files changed, 215 insertions(+), 242 deletions(-) diff --git a/chusst-gen/src/board.rs b/chusst-gen/src/board.rs index 9bba2fb..0a911ec 100644 --- a/chusst-gen/src/board.rs +++ b/chusst-gen/src/board.rs @@ -549,15 +549,14 @@ fn format_board(board: &impl Board, f: &mut fmt::Formatter) -> fmt::Result { rows.push(" a b c d e f g h ".to_owned()); for rank in (0..8).rev() { - let mut row_str = String::from(format!("{} ", rank + 1)); + let mut row_str = format!("{} ", rank + 1); for file in 0..8 { - let piece = match board.at(&pos!(rank, file)) { - Some(square_value) => Some(( + let piece = board.at(&pos!(rank, file)).map(|square_value| { + ( get_unicode_piece(square_value.piece, square_value.player), square_value.player, - )), - None => None, - }; + ) + }); let is_dark_square = square_dark(rank, file); diff --git a/chusst-gen/src/board/bitboards.rs b/chusst-gen/src/board/bitboards.rs index 9a52da9..3293514 100644 --- a/chusst-gen/src/board/bitboards.rs +++ b/chusst-gen/src/board/bitboards.rs @@ -179,7 +179,7 @@ impl PlayerBitboards { impl ModifiableBoard> for PlayerBitboards { fn at(&self, index: &Position) -> Option { - let position_mask = bitboard_from_position(&index); + let position_mask = bitboard_from_position(index); if self.pawns & position_mask != 0 { Some(PieceType::Pawn) } else if self.knights & position_mask != 0 { @@ -332,13 +332,11 @@ impl ModifiableBoard> for Bitboards { player: Player::White, piece, }) - } else if let Some(piece) = self.black.at(pos) { - Some(Piece { + } else { + self.black.at(pos).map(|piece| Piece { player: Player::Black, piece, }) - } else { - None } } diff --git a/chusst-gen/src/board/bitboards/in_between.rs b/chusst-gen/src/board/bitboards/in_between.rs index 9816737..726eaf9 100644 --- a/chusst-gen/src/board/bitboards/in_between.rs +++ b/chusst-gen/src/board/bitboards/in_between.rs @@ -4258,17 +4258,16 @@ mod tests { #[test] fn check_in_between_table() { let inbetween_table = super::IN_BETWEEN_TABLE; - for source_index in 0..64 { - for target_index in 0..64 { + for (source_index, in_between_targets) in inbetween_table.iter().enumerate() { + for (target_index, in_between) in in_between_targets.iter().enumerate() { let source = bitboard_index_to_position(source_index); let target = bitboard_index_to_position(target_index); - let in_between = inbetween_table[source_index][target_index]; let rank_distance = ((source.rank as i8) - (target.rank as i8)).abs(); let file_distance = ((source.file as i8) - (target.file as i8)).abs(); if rank_distance <= 1 && file_distance <= 1 { - assert_eq!(in_between, 0); + assert_eq!(*in_between, 0); continue; } @@ -4287,13 +4286,13 @@ mod tests { 1 << rank_and_file_to_bitboard_index(source.rank, file as usize); } assert_eq!( - in_between, + *in_between, in_between_rank, "source: {}, target: {}, expected:\n{}\nactual:\n{}", source, target, format_bitboard(in_between_rank), - format_bitboard(in_between), + format_bitboard(*in_between), ); } else if same_file { let mut in_between_file = 0; @@ -4305,7 +4304,7 @@ mod tests { in_between_file |= 1 << rank_and_file_to_bitboard_index(rank as usize, source.file); } - assert_eq!(in_between, in_between_file); + assert_eq!(*in_between, in_between_file); } else if same_diagonal { let mut in_between_diagonal = 0; let rank_increment = if source.rank < target.rank { 1i8 } else { -1i8 }; @@ -4320,16 +4319,16 @@ mod tests { } assert_eq!( - in_between, + *in_between, in_between_diagonal, "source: {}, target: {}, expected:\n{}\nactual:\n{}", source, target, format_bitboard(in_between_diagonal), - format_bitboard(in_between), + format_bitboard(*in_between), ); } else { - assert_eq!(in_between, 0); + assert_eq!(*in_between, 0); } } } diff --git a/chusst-gen/src/board/simple.rs b/chusst-gen/src/board/simple.rs index 19e8b48..361589e 100644 --- a/chusst-gen/src/board/simple.rs +++ b/chusst-gen/src/board/simple.rs @@ -8,7 +8,7 @@ use super::{ }; use crate::p; -#[derive(Copy, Clone, Debug, Default, PartialEq)] +#[derive(Clone, Debug, Default, PartialEq)] pub struct SimpleBoard { ranks: Ranks>, } diff --git a/chusst-gen/src/eval.rs b/chusst-gen/src/eval.rs index b0c6c63..4c75d37 100644 --- a/chusst-gen/src/eval.rs +++ b/chusst-gen/src/eval.rs @@ -65,9 +65,9 @@ impl From for Score { } } -impl Into for Score { - fn into(self) -> i32 { - self.0 +impl From for i32 { + fn from(val: Score) -> Self { + val.0 } } @@ -187,7 +187,7 @@ trait GamePrivate: PlayableGame { // Before moving, check if it is a castling and it is valid if is_king && mv.source.file.abs_diff(mv.target.file) == 2 { let is_valid_castling_square = |direction: &Direction| { - only_empty_and_safe(self.board(), try_move(&mv.source, &direction), &player) + only_empty_and_safe(self.board(), try_move(&mv.source, direction), &player) .is_some() }; let can_castle = match mv.target.file { @@ -221,7 +221,7 @@ trait GamePrivate: PlayableGame { if new_game .as_ref() .board() - .is_piece_unsafe(¤t_king_position) + .is_piece_unsafe(current_king_position) { return None; } @@ -303,9 +303,9 @@ trait GamePrivate: PlayableGame { let mut move_names = vec![]; for mv in moves { - move_names.push(Game::move_name(&new_game, &mv).unwrap()); + move_names.push(Game::move_name(&new_game, mv).unwrap()); - assert!(Game::do_move(&mut new_game, *mv).is_some()); + assert!(Game::do_move(&mut new_game, mv).is_some()); } move_names @@ -547,27 +547,24 @@ trait GamePrivate: PlayableGame { fn get_possible_captures_of_position(&self, position: &Position) -> Vec { let mut captures: Vec = Vec::new(); - match self.board().at(position) { - Some(square) => { - for possible_position in self.get_possible_moves_iter(*position) { - let is_capture = self.board().at(&possible_position).is_some(); + if let Some(square) = self.board().at(position) { + for possible_position in self.get_possible_moves_iter(*position) { + let is_capture = self.board().at(&possible_position).is_some(); - if is_capture { - captures.push(possible_position); - } else if !is_capture - && square.piece == PieceType::Pawn - && position.file.abs_diff(position.file) != 0 - { - let passed_rank = usize::try_from( - i8::try_from(position.rank).unwrap() - - B::pawn_progress_direction(&square.player), - ) - .unwrap(); - captures.push(pos!(passed_rank, possible_position.file)); - } + if is_capture { + captures.push(possible_position); + } else if !is_capture + && square.piece == PieceType::Pawn + && position.file.abs_diff(position.file) != 0 + { + let passed_rank = usize::try_from( + i8::try_from(position.rank).unwrap() + - B::pawn_progress_direction(&square.player), + ) + .unwrap(); + captures.push(pos!(passed_rank, possible_position.file)); } } - None => (), } captures @@ -639,9 +636,8 @@ pub trait Game: GamePrivate { let tgt_piece_opt = board.at(&mv.target); let pieces_iter = player_pieces_iter!(board: board, player: player); - match piece_char(&src_piece.piece) { - Some(piece_char_value) => name.push(piece_char_value), - None => (), + if let Some(piece_char_value) = piece_char(&src_piece.piece) { + name.push(piece_char_value); } let is_pawn = src_piece.piece == PieceType::Pawn; @@ -658,19 +654,15 @@ pub trait Game: GamePrivate { continue; } - match board.at(&player_piece_position) { - Some(player_piece) => { - if player_piece.piece != src_piece.piece { - continue; - } + if let Some(player_piece) = board.at(&player_piece_position) { + if player_piece.piece != src_piece.piece { + continue; } - None => {} } if self .get_possible_moves_iter(player_piece_position) - .find(|possible_position| *possible_position == mv.target) - .is_some() + .any(|possible_position| possible_position == mv.target) { ambiguous_piece_exists = true; if player_piece_position.rank == mv.source.rank { @@ -895,7 +887,6 @@ pub trait Game: GamePrivate { Some( enemy_army .keys() - .into_iter() .map(|piece| Piece { piece: *piece, player: *enemy_player, diff --git a/chusst-gen/src/eval/check.rs b/chusst-gen/src/eval/check.rs index b2441f8..f1bf89f 100644 --- a/chusst-gen/src/eval/check.rs +++ b/chusst-gen/src/eval/check.rs @@ -1,22 +1,18 @@ -#[cfg(feature = "bitboards")] -use crate::board::{Bitboards, ModifiableBoard, PlayerBitboards}; #[cfg(feature = "compact-board")] use crate::board::CompactBoard; +#[cfg(feature = "bitboards")] +use crate::board::{Bitboards, ModifiableBoard, PlayerBitboards}; use crate::board::{Board, Piece, PieceType, Player, Position, SimpleBoard}; use crate::eval::conditions::{only_empty, try_move, Direction}; use crate::eval::iter::{dir, into_rolling_board_iterator}; fn find_king(board: &impl Board, player: &Player) -> Position { - match board - .iter() - .filter(|position| { - Some(Piece { - piece: PieceType::King, - player: *player, - }) == board.at(position) - }) - .next() - { + match board.iter().find(|position| { + Some(Piece { + piece: PieceType::King, + player: *player, + }) == board.at(position) + }) { Some(position) => position, None => panic!("no king for player {}:\n{}", player, board), } @@ -39,39 +35,41 @@ fn is_position_unsafe( }; let enemy_in_direction = |direction: &Direction| { - into_rolling_board_iterator(board, &player, &position, direction) + into_rolling_board_iterator(board, player, position, direction) .find_map(|pos| board.at(&pos)) .map(|piece| piece.piece) }; // 1. Pawns if is_enemy_piece( - &try_move(&position, &dir!(enemy_pawn_direction, -1)), + &try_move(position, &dir!(enemy_pawn_direction, -1)), &PieceType::Pawn, ) || is_enemy_piece( - &try_move(&position, &dir!(enemy_pawn_direction, 1)), + &try_move(position, &dir!(enemy_pawn_direction, 1)), &PieceType::Pawn, ) { return true; } // 2. Knights - if is_enemy_piece(&try_move(&position, &dir!(-1, -2)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(-1, 2)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(-2, -1)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(-2, 1)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(2, -1)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(2, 1)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(1, -2)), &PieceType::Knight) - || is_enemy_piece(&try_move(&position, &dir!(1, 2)), &PieceType::Knight) + if is_enemy_piece(&try_move(position, &dir!(-1, -2)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(-1, 2)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(-2, -1)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(-2, 1)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(2, -1)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(2, 1)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(1, -2)), &PieceType::Knight) + || is_enemy_piece(&try_move(position, &dir!(1, 2)), &PieceType::Knight) { return true; } // 3. Bishops or queens on diagonals - let bishop_or_queen = |direction: &Direction| match enemy_in_direction(direction) { - Some(PieceType::Bishop) | Some(PieceType::Queen) => true, - _ => false, + let bishop_or_queen = |direction: &Direction| { + matches!( + enemy_in_direction(direction), + Some(PieceType::Bishop) | Some(PieceType::Queen) + ) }; if bishop_or_queen(&dir!(-1, -1)) @@ -83,9 +81,11 @@ fn is_position_unsafe( } // 4. Rooks or queens on files or ranks - let rook_or_queen = |direction: &Direction| match enemy_in_direction(direction) { - Some(PieceType::Rook) | Some(PieceType::Queen) => true, - _ => false, + let rook_or_queen = |direction: &Direction| { + matches!( + enemy_in_direction(direction), + Some(PieceType::Rook) | Some(PieceType::Queen) + ) }; if rook_or_queen(&dir!(0, -1)) @@ -97,14 +97,14 @@ fn is_position_unsafe( } // 6. King - if is_enemy_piece(&try_move(&position, &dir!(-1, -1)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(-1, 0)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(-1, 1)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(0, -1)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(0, 1)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(1, -1)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(1, 0)), &PieceType::King) - || is_enemy_piece(&try_move(&position, &dir!(1, 1)), &PieceType::King) + if is_enemy_piece(&try_move(position, &dir!(-1, -1)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(-1, 0)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(-1, 1)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(0, -1)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(0, 1)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(1, -1)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(1, 0)), &PieceType::King) + || is_enemy_piece(&try_move(position, &dir!(1, 1)), &PieceType::King) { return true; } @@ -117,7 +117,7 @@ fn is_position_unsafe_generic(board: &B, position: &Position, player: is_position_unsafe(board, position, player, pd) } -fn is_piece_unsafe(board: &impl Board, position: &Position) -> bool { +fn is_piece_unsafe(board: &impl Board, position: &Position) -> bool { let Some(Piece { piece: _, player }) = board.at(position) else { panic!("No piece at position {}:\n{}", position, board); }; @@ -158,7 +158,7 @@ impl SafetyChecks for SimpleBoard { } fn is_piece_unsafe(&self, position: &Position) -> bool { - is_piece_unsafe::(self, position) + is_piece_unsafe(self, position) } } @@ -173,7 +173,7 @@ impl SafetyChecks for CompactBoard { } fn is_piece_unsafe(&self, position: &Position) -> bool { - is_piece_unsafe::(self, position) + is_piece_unsafe(self, position) } } @@ -191,7 +191,7 @@ impl SafetyChecks for Bitboards { } fn is_position_unsafe(&self, position: &Position, player: &Player) -> bool { - let player_bitboards = self.by_player(&player); + let player_bitboards = self.by_player(player); let enemy_bitboards = self.by_player(&!*player); let all_pieces_bitboard = player_bitboards.combined() | enemy_bitboards.combined(); diff --git a/chusst-gen/src/eval/conditions.rs b/chusst-gen/src/eval/conditions.rs index 552b490..7aad30a 100644 --- a/chusst-gen/src/eval/conditions.rs +++ b/chusst-gen/src/eval/conditions.rs @@ -12,11 +12,11 @@ pub fn try_move(position: &Position, direction: &Direction) -> Option let row = i8::try_from(position.rank).unwrap() + direction.row_inc; let col = i8::try_from(position.file).unwrap() + direction.col_inc; - if row < 0 || row >= 8 { + if !(0..8).contains(&row) { return None; } - if col < 0 || col >= 8 { + if !(0..8).contains(&col) { return None; } diff --git a/chusst-gen/src/eval/feedback.rs b/chusst-gen/src/eval/feedback.rs index f40c86e..4b8366d 100644 --- a/chusst-gen/src/eval/feedback.rs +++ b/chusst-gen/src/eval/feedback.rs @@ -19,19 +19,19 @@ pub trait EngineFeedback: std::io::Write { } pub trait SearchFeedback: std::io::Write { - fn update(self: &mut Self, depth: u32, nodes: u32, score: i32); - fn info(self: &mut Self, message: &str); + fn update(&mut self, depth: u32, nodes: u32, score: i32); + fn info(&mut self, message: &str); } #[derive(Default)] pub struct SilentSearchFeedback(); impl SearchFeedback for SilentSearchFeedback { - fn update(self: &mut Self, _depth: u32, _nodes: u32, _score: i32) { + fn update(&mut self, _depth: u32, _nodes: u32, _score: i32) { // do nothing } - fn info(self: &mut Self, message: &str) { + fn info(&mut self, message: &str) { println!("{}", message); } } @@ -66,7 +66,7 @@ impl<'a> PeriodicalSearchFeedback<'a> { } impl<'a> SearchFeedback for PeriodicalSearchFeedback<'a> { - fn update(self: &mut Self, depth: u32, nodes: u32, score: i32) { + fn update(&mut self, depth: u32, nodes: u32, score: i32) { let now = std::time::Instant::now(); if now - self.last_update < self.update_interval { @@ -83,7 +83,7 @@ impl<'a> SearchFeedback for PeriodicalSearchFeedback<'a> { self.last_update = now; } - fn info(self: &mut Self, message: &str) { + fn info(&mut self, message: &str) { self.receiver.send(EngineMessage::Info(EngineInfoMessage { message: message.to_string(), })) @@ -110,11 +110,11 @@ impl EngineFeedback for StdoutFeedback { } impl SearchFeedback for StdoutFeedback { - fn update(self: &mut Self, _depth: u32, _nodes: u32, _score: i32) { + fn update(&mut self, _depth: u32, _nodes: u32, _score: i32) { // ignore } - fn info(self: &mut Self, message: &str) { + fn info(&mut self, message: &str) { println!("{}", message); } } diff --git a/chusst-gen/src/eval/iter.rs b/chusst-gen/src/eval/iter.rs index 56fdf7c..cca90da 100644 --- a/chusst-gen/src/eval/iter.rs +++ b/chusst-gen/src/eval/iter.rs @@ -17,7 +17,7 @@ impl Default for BoardIter { } } -impl<'a> Iterator for BoardIter { +impl Iterator for BoardIter { type Item = Position; fn next(&mut self) -> Option { @@ -59,7 +59,7 @@ impl<'a, B: Board> Iterator for PlayerPiecesIter<'a, B> { type Item = Position; fn next(&mut self) -> Option { - while let Some(position) = self.board_iter.next() { + for position in self.board_iter.by_ref() { if let Some(Piece { piece: _, player }) = self.board.at(&position) { if player == *self.player { return Some(position); @@ -153,13 +153,13 @@ struct PieceIterGameState<'a, B: Board> { } pub enum PawnIterStates { - PawnIterNormal, - PawnIterPass, - PawnIterCaptureLeft, - PawnIterCaptureRight, - PawnIterCaptureEnPassantLeft, - PawnIterCaptureEnPassantRight, - PawnIterEnd, + Normal, + Pass, + CaptureLeft, + CaptureRight, + CaptureEnPassantLeft, + CaptureEnPassantRight, + End, } pub enum KnightIterStates { @@ -246,54 +246,54 @@ type QueenIter<'a, B> = RollingPieceIter<'a, B, QueenIterStates>; type KingIter<'a, B> = PositionalPieceIter<'a, B, KingIterStates>; pub enum PieceIter<'a, B: Board> { - EmptySquareIterType(std::iter::Empty), - PawnIterType(PawnIter<'a, B>), - KnightIterType(KnightIter<'a, B>), - BishopIterType(BishopIter<'a, B>), - RookIterType(RookIter<'a, B>), - QueenIterType(QueenIter<'a, B>), - KingIterType(KingIter<'a, B>), + EmptySquare(std::iter::Empty), + Pawn(PawnIter<'a, B>), + Knight(KnightIter<'a, B>), + Bishop(BishopIter<'a, B>), + Rook(RookIter<'a, B>), + Queen(QueenIter<'a, B>), + King(KingIter<'a, B>), } -pub fn piece_into_iter<'a, B: Board>( - game: &'a GameState, +pub fn piece_into_iter( + game: &GameState, position: Position, -) -> impl Iterator + 'a { +) -> impl Iterator + '_ { let Some(Piece { piece, player }) = game.board.at(&position) else { // println!("Square {} is empty", position); - return PieceIter::EmptySquareIterType(std::iter::empty()); + return PieceIter::EmptySquare(std::iter::empty()); }; let game_state = PieceIterGameState { game, position }; match piece { - PieceType::Pawn => PieceIter::PawnIterType(PawnIter { + PieceType::Pawn => PieceIter::Pawn(PawnIter { game_state, - state: PawnIterStates::PawnIterNormal, + state: PawnIterStates::Normal, }), - PieceType::Knight => PieceIter::KnightIterType(KnightIter { + PieceType::Knight => PieceIter::Knight(KnightIter { game_state, state: KnightIterStates::KnightIter0, }), - PieceType::Bishop => PieceIter::BishopIterType(BishopIter { + PieceType::Bishop => PieceIter::Bishop(BishopIter { game_state, state: BishopIterStates::BishopIter0, - player: player, + player, walker: None, }), - PieceType::Rook => PieceIter::RookIterType(RookIter { + PieceType::Rook => PieceIter::Rook(RookIter { game_state, state: RookIterStates::RookIter0, - player: player, + player, walker: None, }), - PieceType::Queen => PieceIter::QueenIterType(QueenIter { + PieceType::Queen => PieceIter::Queen(QueenIter { game_state, state: QueenIterStates::QueenIter0, - player: player, + player, walker: None, }), - PieceType::King => PieceIter::KingIterType(KingIter { + PieceType::King => PieceIter::King(KingIter { game_state, state: KingIterStates::KingIter0, }), @@ -305,13 +305,13 @@ impl<'a, B: Board> Iterator for PieceIter<'a, B> { fn next(&mut self) -> Option { match self { - PieceIter::EmptySquareIterType(iter) => iter.next(), - PieceIter::PawnIterType(iter) => iter.next(), - PieceIter::KnightIterType(iter) => iter.next(), - PieceIter::BishopIterType(iter) => iter.next(), - PieceIter::RookIterType(iter) => iter.next(), - PieceIter::QueenIterType(iter) => iter.next(), - PieceIter::KingIterType(iter) => iter.next(), + PieceIter::EmptySquare(iter) => iter.next(), + PieceIter::Pawn(iter) => iter.next(), + PieceIter::Knight(iter) => iter.next(), + PieceIter::Bishop(iter) => iter.next(), + PieceIter::Rook(iter) => iter.next(), + PieceIter::Queen(iter) => iter.next(), + PieceIter::King(iter) => iter.next(), } } } @@ -329,15 +329,15 @@ impl<'a, B: Board> Iterator for PawnIter<'a, B> { }; loop { let result = match self.state { - PawnIterStates::PawnIterNormal => { - self.state = PawnIterStates::PawnIterPass; + PawnIterStates::Normal => { + self.state = PawnIterStates::Pass; only_empty( &self.game_state.game.board, try_move(&self.game_state.position, &dir!(direction, 0)), ) } - PawnIterStates::PawnIterPass => { - self.state = PawnIterStates::PawnIterCaptureLeft; + PawnIterStates::Pass => { + self.state = PawnIterStates::CaptureLeft; if can_pass && only_empty( &self.game_state.game.board, @@ -353,24 +353,24 @@ impl<'a, B: Board> Iterator for PawnIter<'a, B> { None } } - PawnIterStates::PawnIterCaptureLeft => { - self.state = PawnIterStates::PawnIterCaptureRight; + PawnIterStates::CaptureLeft => { + self.state = PawnIterStates::CaptureRight; only_enemy( &self.game_state.game.board, try_move(&self.game_state.position, &dir!(direction, -1)), player, ) } - PawnIterStates::PawnIterCaptureRight => { - self.state = PawnIterStates::PawnIterCaptureEnPassantLeft; + PawnIterStates::CaptureRight => { + self.state = PawnIterStates::CaptureEnPassantLeft; only_enemy( &self.game_state.game.board, try_move(&self.game_state.position, &dir!(direction, 1)), player, ) } - PawnIterStates::PawnIterCaptureEnPassantLeft => { - self.state = PawnIterStates::PawnIterCaptureEnPassantRight; + PawnIterStates::CaptureEnPassantLeft => { + self.state = PawnIterStates::CaptureEnPassantRight; only_en_passant( &self.game_state.game.board, &self.game_state.game.last_move, @@ -379,8 +379,8 @@ impl<'a, B: Board> Iterator for PawnIter<'a, B> { direction, ) } - PawnIterStates::PawnIterCaptureEnPassantRight => { - self.state = PawnIterStates::PawnIterEnd; + PawnIterStates::CaptureEnPassantRight => { + self.state = PawnIterStates::End; only_en_passant( &self.game_state.game.board, &self.game_state.game.last_move, @@ -389,12 +389,11 @@ impl<'a, B: Board> Iterator for PawnIter<'a, B> { direction, ) } - PawnIterStates::PawnIterEnd => return None, + PawnIterStates::End => return None, }; - match result { - Some(position) => return Some(position), - None => (), + if let Some(position) = result { + return Some(position); } } } @@ -468,9 +467,8 @@ impl<'a, B: Board> Iterator for KnightIter<'a, B> { KnightIterStates::KnightIterEnd => return None, }; - match result { - Some(position) => return Some(position), - None => (), + if let Some(position) = result { + return Some(position); } } } @@ -497,9 +495,8 @@ impl<'a, B: Board> Iterator for BishopIter<'a, B> { BishopIterStates::BishopIterEnd => return None, }; - match result { - Some(position) => return Some(position), - None => (), + if let Some(position) = result { + return Some(position); } } } @@ -526,9 +523,8 @@ impl<'a, B: Board> Iterator for RookIter<'a, B> { RookIterStates::RookIterEnd => return None, }; - match result { - Some(position) => return Some(position), - None => (), + if let Some(position) = result { + return Some(position); } } } @@ -567,9 +563,8 @@ impl<'a, B: Board> Iterator for QueenIter<'a, B> { QueenIterStates::QueenIterEnd => return None, }; - match result { - Some(position) => return Some(position), - None => (), + if let Some(position) = result { + return Some(position); } } } @@ -651,9 +646,8 @@ impl<'a, B: Board> Iterator for KingIter<'a, B> { KingIterStates::KingIterEnd => return None, }; - match result { - Some(position) => return Some(position), - None => (), + if let Some(position) = result { + return Some(position); } } } diff --git a/chusst-gen/src/eval/play.rs b/chusst-gen/src/eval/play.rs index 641a888..3f73fc0 100644 --- a/chusst-gen/src/eval/play.rs +++ b/chusst-gen/src/eval/play.rs @@ -47,10 +47,9 @@ where let possible_moves = self.as_ref().get_possible_moves(mv.source); - if possible_moves + if !possible_moves .iter() - .find(|possible_move| mv.target == possible_move.mv.target) - .is_none() + .any(|possible_move| mv.target == possible_move.mv.target) { return false; } @@ -168,11 +167,11 @@ pub struct ReversableGame<'a, B: Board> { impl<'a, B: Board + SafetyChecks> PlayableGame for ReversableGame<'a, B> { fn as_ref(&self) -> &GameState { - &self.game + self.game } fn as_mut(&mut self) -> &mut GameState { - &mut self.game + self.game } fn do_move_no_checks(&mut self, mv: &MoveAction) -> Result<()> { @@ -204,7 +203,7 @@ impl<'a, B: Board + SafetyChecks> ModifiableBoard> mv: mv!(*pos, *pos), previous_piece: self.as_ref().board.at(pos), }); - self.as_mut().board.update(&pos, value); + self.as_mut().board.update(pos, value); } } diff --git a/chusst-gen/src/eval/tests.rs b/chusst-gen/src/eval/tests.rs index ad525b6..d918be2 100644 --- a/chusst-gen/src/eval/tests.rs +++ b/chusst-gen/src/eval/tests.rs @@ -41,15 +41,15 @@ fn custom_board(board_opt: &Option<&str>) -> B { let mut rank = 8usize; for line in board_str.lines() { - match line.find("[") { + match line.find('[') { Some(position) => { - let mut file = 0usize; rank -= 1; - for piece_char in line + for (file, piece_char) in line .chars() .skip(position) .filter(|c| *c != '[' && *c != ']') + .enumerate() { let piece = match piece_char { '♙' => p!(pw), @@ -73,7 +73,6 @@ fn custom_board(board_opt: &Option<&str>) -> B { } }; board.update(&pos!(rank, file), piece); - file += 1; } } None => continue, @@ -229,7 +228,7 @@ fn move_reversable() { // Do setup moves for mv in &test_board.initial_moves { assert!( - game.do_move(&mv).is_some(), + game.do_move(mv).is_some(), "move {} failed:\n{}", mv.mv, game.board @@ -379,7 +378,7 @@ fn check_mate() { // Do setup moves for mv in &test_board.initial_moves { assert!( - game.do_move(&mv).is_some(), + game.do_move(mv).is_some(), "move {} failed:\n{}", mv.mv, game.board @@ -388,7 +387,7 @@ fn check_mate() { let name = game.move_name(&test_board.mv).unwrap(); assert!( - name.ends_with("#"), + name.ends_with('#'), "notation `{}` for move {} doesn't show checkmate sign # in:\n{}", name, test_board.mv.mv, @@ -469,7 +468,7 @@ fn quick_test() { // Do setup moves for mv in &test_board.initial_moves { assert!( - game.do_move(&mv).is_some(), + game.do_move(mv).is_some(), "move {} failed:\n{}", mv.mv, game.board diff --git a/chusst-gen/src/game.rs b/chusst-gen/src/game.rs index a94b83c..67cc2c6 100644 --- a/chusst-gen/src/game.rs +++ b/chusst-gen/src/game.rs @@ -1,6 +1,4 @@ -use crate::board::{ - Board, ModifiableBoard, Piece, PieceType, Player, Position, SimpleBoard, -}; +use crate::board::{Board, ModifiableBoard, Piece, PieceType, Player, Position, SimpleBoard}; use crate::{mv, pos}; use serde::Serialize; @@ -75,8 +73,7 @@ impl MoveAction { let promotion = mv_str .chars() .nth(4) - .map(PromotionPieces::try_from_char) - .flatten(); + .and_then(PromotionPieces::try_from_char); match (source, target, promotion) { (Some(src_pos), Some(tgt_pos), None) => Some(MoveAction { diff --git a/chusst-uci/src/engine.rs b/chusst-uci/src/engine.rs index 7a9bca7..0003af8 100644 --- a/chusst-uci/src/engine.rs +++ b/chusst-uci/src/engine.rs @@ -183,8 +183,8 @@ fn engine_thread( } } -pub fn create_engine_thread<'scope, 'env>( - scope: &'scope std::thread::Scope<'scope, 'env>, +pub fn create_engine_thread<'scope>( + scope: &'scope std::thread::Scope<'scope, '_>, ) -> DuplexThread<'scope, EngineCommand, EngineResponse> { create_duplex_thread(scope, engine_thread) } diff --git a/chusst-uci/src/main.rs b/chusst-uci/src/main.rs index 9e1203a..ee8b0d6 100644 --- a/chusst-uci/src/main.rs +++ b/chusst-uci/src/main.rs @@ -85,7 +85,7 @@ impl fmt::Display for UciProtocolState { } } -fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { +fn uci_loop<'scope>(scope: &'scope std::thread::Scope<'scope, '_>) { let mut logger = Logger { file: match std::fs::OpenOptions::new() .write(true) @@ -152,8 +152,8 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { let get_input = || -> Result { select! { - recv(stdin_thread.from_thread) -> stdin_line => return Ok(SyncInput::FromStdin(stdin_line.map_err(stringify_stdin_err)?)), - recv(engine_thread.from_thread) -> engine_response => return Ok(SyncInput::FromEngine(engine_response.map_err(stringify_engine_err)?)), + recv(stdin_thread.from_thread) -> stdin_line => Ok(SyncInput::FromStdin(stdin_line.map_err(stringify_stdin_err)?)), + recv(engine_thread.from_thread) -> engine_response => Ok(SyncInput::FromEngine(engine_response.map_err(stringify_engine_err)?)), } }; @@ -287,13 +287,13 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { write_command!("readyok") } (Some(UciProtocolOutput::EngineCommandNewGame), ParsedInput::UciStdInInput(_)) => { - if let Err(_) = - engine_thread - .to_thread - .send(EngineCommand::NewGame(NewGameCommand { - game: Some(BitboardGame::new()), - moves: Vec::new(), - })) + if engine_thread + .to_thread + .send(EngineCommand::NewGame(NewGameCommand { + game: Some(BitboardGame::new()), + moves: Vec::new(), + })) + .is_err() { log!("Error: could not send new game to engine"); break; @@ -318,7 +318,8 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { .map_while(|token| *token) .collect(); - if let Some(new_game_from_fen) = BitboardGame::try_from_fen(fen.as_slice()) { + if let Some(new_game_from_fen) = BitboardGame::try_from_fen(fen.as_slice()) + { (param_iter.next(), Some(new_game_from_fen)) } else { log!("Malformed FEN string in position command"); @@ -332,7 +333,7 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { } }; if let Some(game) = &new_game { - let _ = log!("New position:\n{}", game.board()); + log!("New position:\n{}", game.board()); } let mut new_game_command = NewGameCommand { game: new_game, @@ -341,7 +342,7 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { match next_token { Some("moves") => { for mv_str in param_iter { - if let Some(mv) = MoveAction::try_from_long_algebraic_str(&mv_str) { + if let Some(mv) = MoveAction::try_from_long_algebraic_str(mv_str) { new_game_command.moves.push(mv); } else { log!("Malformed move in position command"); @@ -397,7 +398,7 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { last_best_move = Some(best_move_result); } (Some(UciProtocolOutput::EngineCommandStop), ParsedInput::UciStdInInput(_)) => { - if let Err(_) = engine_thread.to_thread.send(EngineCommand::Stop) { + if engine_thread.to_thread.send(EngineCommand::Stop).is_err() { log!("Error: could not send go command to engine"); break; } @@ -407,7 +408,7 @@ fn uci_loop<'scope, 'env>(scope: &'scope std::thread::Scope<'scope, 'env>) { ParsedInput::UciStdInInput(_), ) => { if let Some(best_move) = &last_best_move { - let best_move_str = move_to_uci_string(&best_move); + let best_move_str = move_to_uci_string(best_move); write_command!("bestmove {}", best_move_str); } } diff --git a/chusst-uci/src/stdin.rs b/chusst-uci/src/stdin.rs index ef5278c..9f297da 100644 --- a/chusst-uci/src/stdin.rs +++ b/chusst-uci/src/stdin.rs @@ -34,8 +34,8 @@ fn stdin_thread( } } -pub fn create_stdin_thread<'scope, 'env>( - scope: &'scope std::thread::Scope<'scope, 'env>, +pub fn create_stdin_thread<'scope>( + scope: &'scope std::thread::Scope<'scope, '_>, ) -> DuplexThread<'scope, (), StdinResponse> { create_duplex_thread(scope, stdin_thread) } diff --git a/pgn2yaml/src/converter.rs b/pgn2yaml/src/converter.rs index b164831..8599116 100644 --- a/pgn2yaml/src/converter.rs +++ b/pgn2yaml/src/converter.rs @@ -3,13 +3,13 @@ mod serializer; use self::interpreter::pgn_to_long_algebraic; use self::serializer::write_yaml; -use crate::reader::PGN; +use crate::reader::Pgn; use anyhow::{Context, Result}; use std::path::PathBuf; -pub fn write_pgn(pgn: &PGN, path: &PathBuf) -> Result<()> { +pub fn write_pgn(pgn: &Pgn, path: &PathBuf) -> Result<()> { let detailed_game = - pgn_to_long_algebraic(&pgn).context("Cannot convert to long algebraic form")?; - write_yaml(&path, &detailed_game)?; + pgn_to_long_algebraic(pgn).context("Cannot convert to long algebraic form")?; + write_yaml(path, &detailed_game)?; Ok(()) } diff --git a/pgn2yaml/src/converter/interpreter.rs b/pgn2yaml/src/converter/interpreter.rs index a1c8025..854ba2c 100644 --- a/pgn2yaml/src/converter/interpreter.rs +++ b/pgn2yaml/src/converter/interpreter.rs @@ -1,4 +1,4 @@ -use crate::reader::{Tag, PGN}; +use crate::reader::{Tag, Pgn}; use anyhow::{bail, Result}; use chusst_gen::{ board::{Piece, PieceType, ModifiableBoard}, @@ -76,7 +76,7 @@ fn find_move_by_name(game: &SimpleGame, move_str: &str) -> Result Result Result>() .join(", ") ); @@ -164,7 +163,7 @@ fn is_stalemate(game: &SimpleGame) -> bool { game.get_all_possible_moves().is_empty() } -pub fn pgn_to_long_algebraic(pgn: &PGN) -> Result { +pub fn pgn_to_long_algebraic(pgn: &Pgn) -> Result { let mut game = SimpleGame::new(); let mut detailed = DetailedGame { tags: pgn.tags.clone(), diff --git a/pgn2yaml/src/converter/serializer.rs b/pgn2yaml/src/converter/serializer.rs index 6c59e90..1eef816 100644 --- a/pgn2yaml/src/converter/serializer.rs +++ b/pgn2yaml/src/converter/serializer.rs @@ -118,7 +118,7 @@ impl<'a> Serialize for SerializedMoveList<'a> { struct SerializedGameEnding(GameEnding); -impl<'a> Serialize for SerializedGameEnding { +impl Serialize for SerializedGameEnding { fn serialize(&self, serializer: S) -> std::prelude::v1::Result where S: serde::Serializer, diff --git a/pgn2yaml/src/main.rs b/pgn2yaml/src/main.rs index fdb6b02..5c66211 100644 --- a/pgn2yaml/src/main.rs +++ b/pgn2yaml/src/main.rs @@ -50,7 +50,7 @@ fn main() -> Result<()> { index, path.extension().unwrap().to_string_lossy() )); - write_pgn(&pgn, &path)?; + write_pgn(pgn, &path)?; } } } diff --git a/pgn2yaml/src/reader.rs b/pgn2yaml/src/reader.rs index e7c5ba9..3362d6a 100644 --- a/pgn2yaml/src/reader.rs +++ b/pgn2yaml/src/reader.rs @@ -1,12 +1,12 @@ mod lexer; mod parser; -pub use self::parser::{Tag, PGN}; +pub use self::parser::{Tag, Pgn}; use anyhow::Result; use parser::Parser; use std::path::PathBuf; -pub fn parse_pgn_file(pgn_file_path: &PathBuf) -> Result> { +pub fn parse_pgn_file(pgn_file_path: &PathBuf) -> Result> { Parser::parse_file(pgn_file_path) } diff --git a/pgn2yaml/src/reader/parser.rs b/pgn2yaml/src/reader/parser.rs index b16076c..cd0e1a3 100644 --- a/pgn2yaml/src/reader/parser.rs +++ b/pgn2yaml/src/reader/parser.rs @@ -14,7 +14,7 @@ pub struct Tag { } #[derive(Default)] -pub struct PGN { +pub struct Pgn { pub tags: Vec, pub moves: Vec, pub result: String, @@ -22,23 +22,23 @@ pub struct PGN { #[derive(Default)] pub struct Parser { - pgns: Vec, - current: Option, + pgns: Vec, + current: Option, variation_level: u32, } impl Parser { - pub fn parse_file(path: &PathBuf) -> Result> { + pub fn parse_file(path: &PathBuf) -> Result> { let mut parser = Parser::default(); parser.parse_file(path)?; Ok(parser.pgns) } - fn current(&self) -> Result<&PGN> { + fn current(&self) -> Result<&Pgn> { self.current.as_ref().context("No current game") } - fn current_mut(&mut self) -> Result<&mut PGN> { + fn current_mut(&mut self) -> Result<&mut Pgn> { self.current.as_mut().context("No current game") } @@ -56,7 +56,7 @@ impl LexerVisitor for Parser { bail!("Unexpected new game"); } - self.current = Some(PGN::default()); + self.current = Some(Pgn::default()); Ok(()) } diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs index d492680..befbc5f 100644 --- a/src-tauri/src/main.rs +++ b/src-tauri/src/main.rs @@ -55,8 +55,7 @@ fn get_history() -> Vec { fn get_possible_moves(rank: usize, file: usize) -> Vec { let position = Position { rank, file }; let game = &mut GAME.lock().unwrap().game; - let possible_moves = game.get_possible_targets(position); - possible_moves + game.get_possible_targets(position) } #[tauri::command] @@ -73,9 +72,7 @@ fn do_move( target_file: usize, promotion: Option, ) -> bool { - let promotion_piece = promotion - .map(|piece_str| PromotionPieces::try_from_str(piece_str)) - .flatten(); + let promotion_piece = promotion.and_then(PromotionPieces::try_from_str); let mv = MoveAction { mv: Move { source: Position { From affa59444d15cbe3f48a1118166ccfe9595e6598 Mon Sep 17 00:00:00 2001 From: Oriol Arcas Date: Tue, 16 Jan 2024 14:59:38 +0100 Subject: [PATCH 2/3] Reduce number of arguments of get_best_move_recursive_alpha_beta --- chusst-gen/src/eval.rs | 44 +++++++++++++++++++++++++++--------------- 1 file changed, 28 insertions(+), 16 deletions(-) diff --git a/chusst-gen/src/eval.rs b/chusst-gen/src/eval.rs index 4c75d37..bdf9c2a 100644 --- a/chusst-gen/src/eval.rs +++ b/chusst-gen/src/eval.rs @@ -139,6 +139,22 @@ struct SearchResult { stopped: bool, } +struct SearchScores { + parent: Score, + alpha: Score, + beta: Score, +} + +impl Default for SearchScores { + fn default() -> Self { + Self { + parent: Score::from(0), + alpha: Score::MIN, + beta: Score::MAX, + } + } +} + // Value in centipawns fn get_piece_value(piece: PieceType) -> Score { match piece { @@ -316,9 +332,7 @@ trait GamePrivate: PlayableGame { &self, current_depth: u32, max_depth: u32, - alpha: Score, - beta: Score, - parent_score: Score, + scores: SearchScores, stop_signal: &mut impl HasStopSignal, feedback: &mut impl SearchFeedback, ) -> SearchResult { @@ -334,7 +348,7 @@ trait GamePrivate: PlayableGame { let king_position = self.board().find_king(&player); - let mut local_alpha = alpha; + let mut local_alpha = scores.alpha; let is_leaf_node = current_depth == max_depth; let mut stopped = false; @@ -384,7 +398,7 @@ trait GamePrivate: PlayableGame { score: local_score, }], // Negamax: negate score from previous move - score: local_score - parent_score, + score: local_score - scores.parent, searched: 0, }; @@ -411,9 +425,11 @@ trait GamePrivate: PlayableGame { current_depth + 1, max_depth, // beta becomes the alpha of the other player, and viceversa - -beta, - -local_alpha, - branch.score, + SearchScores { + parent: branch.score, + alpha: -scores.beta, + beta: -local_alpha, + }, stop_signal, feedback, ); @@ -471,7 +487,7 @@ trait GamePrivate: PlayableGame { let _ = writeln!(feedback, "{}}}", indent(current_depth)); } - if branch.score >= beta && branch.score < Score::MAX { + if branch.score >= scores.beta && branch.score < Score::MAX { // Fail hard beta cutoff #[cfg(feature = "verbose-search")] @@ -489,7 +505,7 @@ trait GamePrivate: PlayableGame { best_move = Some(branch); } - best_move.as_mut().unwrap().score = beta; + best_move.as_mut().unwrap().score = scores.beta; break 'main_loop; } @@ -535,9 +551,7 @@ trait GamePrivate: PlayableGame { self.get_best_move_recursive_alpha_beta( 0, 0, - Score::MIN, - Score::MAX, - Score::from(0), + SearchScores::default(), &mut (), &mut SilentSearchFeedback::default(), ) @@ -738,9 +752,7 @@ pub trait Game: GamePrivate { self.get_best_move_recursive_alpha_beta( 0, search_depth, - Score::MIN, - Score::MAX, - Score::from(0), + SearchScores::default(), stop_signal, feedback, ) From 6276b5cc22d60207b592221c6f5075bb14f1df0d Mon Sep 17 00:00:00 2001 From: Oriol Arcas Date: Wed, 17 Jan 2024 12:01:20 +0100 Subject: [PATCH 3/3] Fix Clippy warning in chusst-uci --- chusst-uci/src/engine.rs | 30 +++++++++++++----------------- chusst-uci/src/main.rs | 2 +- 2 files changed, 14 insertions(+), 18 deletions(-) diff --git a/chusst-uci/src/engine.rs b/chusst-uci/src/engine.rs index 0003af8..9f4ae0e 100644 --- a/chusst-uci/src/engine.rs +++ b/chusst-uci/src/engine.rs @@ -65,11 +65,11 @@ impl<'a> HasStopSignal for EngineCommandReceiver<'a> { } } -struct SenderWriter<'a> { - sender: std::rc::Rc<&'a mut crossbeam_channel::Sender>, +struct SenderWriter { + sender: std::rc::Rc>, } -impl<'a> std::io::Write for SenderWriter<'a> { +impl std::io::Write for SenderWriter { fn write(&mut self, buf: &[u8]) -> std::io::Result { let msg = String::from_utf8(buf.to_vec()) .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err))?; @@ -85,25 +85,22 @@ impl<'a> std::io::Write for SenderWriter<'a> { } } -struct BufferedSenderWriter<'a> { - sender: std::rc::Rc<&'a mut crossbeam_channel::Sender>, - writer: std::io::LineWriter>, +struct BufferedSenderWriter { + sender: std::rc::Rc>, + writer: std::io::LineWriter, } -impl<'a> BufferedSenderWriter<'a> { - fn new(sender: &'a mut crossbeam_channel::Sender) -> BufferedSenderWriter<'a> { +impl BufferedSenderWriter { + fn new(sender: crossbeam_channel::Sender) -> BufferedSenderWriter { let sender_rc = std::rc::Rc::new(sender); - BufferedSenderWriter { sender: sender_rc.clone(), - writer: std::io::LineWriter::new(SenderWriter { - sender: sender_rc.clone(), - }), + writer: std::io::LineWriter::new(SenderWriter { sender: sender_rc }), } } } -impl<'a> std::io::Write for BufferedSenderWriter<'a> { +impl std::io::Write for BufferedSenderWriter { fn write(&mut self, buf: &[u8]) -> std::io::Result { self.writer.write(buf) } @@ -113,7 +110,7 @@ impl<'a> std::io::Write for BufferedSenderWriter<'a> { } } -impl<'a> BufferedSenderWriter<'a> { +impl BufferedSenderWriter { fn send( &self, msg: EngineResponse, @@ -122,7 +119,7 @@ impl<'a> BufferedSenderWriter<'a> { } } -impl<'a> EngineFeedback for BufferedSenderWriter<'a> { +impl EngineFeedback for BufferedSenderWriter { fn send(&self, msg: EngineMessage) { match msg { EngineMessage::Info(msg) => { @@ -139,8 +136,7 @@ fn engine_thread( to_engine: crossbeam_channel::Receiver, from_engine: crossbeam_channel::Sender, ) { - let mut from_engine_mut = from_engine; - let mut communicator = BufferedSenderWriter::new(&mut from_engine_mut); + let mut communicator = BufferedSenderWriter::new(from_engine); let mut game = BitboardGame::new(); let mut command_receiver = EngineCommandReceiver { receiver: &to_engine, diff --git a/chusst-uci/src/main.rs b/chusst-uci/src/main.rs index ee8b0d6..35902b0 100644 --- a/chusst-uci/src/main.rs +++ b/chusst-uci/src/main.rs @@ -91,7 +91,7 @@ fn uci_loop<'scope>(scope: &'scope std::thread::Scope<'scope, '_>) { .write(true) .create(true) .truncate(true) - .open("uci.log") + .open(format!("uci.{}.log", std::process::id())) { Ok(file) => file, Err(err) => {