Fix lints

Author: confusinguser

Diff for: .gitignore

@@ -1 +1,2 @@
 /target
+.idea

Diff for: src/algorithms/the_algorithm.rs

@@ -1,10 +1,10 @@
 use std::collections::HashMap;
-use tokio::time::{Duration, Instant};
 
 use chess::{Action, BitBoard, Board, BoardStatus, ChessMove, Color, MoveGen, Piece};
+use tokio::time::{Duration, Instant};
 
 use crate::common::constants::{
-    modules::{self, *},
+    modules::*,
     naive_psqt_tables::*,
     tapered_pesto_psqt_tables::*,
 };
@@ -134,7 +134,7 @@ impl Algorithm {
                 // node on our layer
                 stats.progress_on_next_layer *= 1. / num_legal_moves as f32;
                 stats.progress_on_next_layer +=
-                    (i.saturating_sub(1)) as f32 / num_legal_moves as f32;
+                    i.saturating_sub(1) as f32 / num_legal_moves as f32;
                 return best_evaluation;
             };
 
@@ -182,7 +182,7 @@ impl Algorithm {
                         num_extensions + extend_by,
                         board_played_times_prediction,
                         mg_incremental_psqt_eval,
-                        eg_incremental_psqt_eval
+                        eg_incremental_psqt_eval,
                     );
                     board_played_times_prediction.insert(
                         new_board,
@@ -196,8 +196,8 @@ impl Algorithm {
             // Replace best_eval if ours is better
             if evaluation.eval.is_some()
                 && (best_evaluation.eval.is_none()
-                    || maximise && evaluation.eval.unwrap() > best_evaluation.eval.unwrap()
-                    || !maximise && evaluation.eval.unwrap() < best_evaluation.eval.unwrap())
+                || maximise && evaluation.eval.unwrap() > best_evaluation.eval.unwrap()
+                || !maximise && evaluation.eval.unwrap() < best_evaluation.eval.unwrap())
             {
                 if original && module_enabled(self.modules, ANALYZE) {
                     let mut vec = Vec::new();
@@ -238,19 +238,19 @@ impl Algorithm {
                 }
             }
 
-            if utils::module_enabled(self.modules, modules::TAPERED_INCREMENTAL_PESTO_PSQT) {
+            if module_enabled(self.modules, TAPERED_INCREMENTAL_PESTO_PSQT) {
                 fn calc_increment(
                     piece_type: Piece,
                     location: usize,
-                    mg_eg: bool
+                    mg_eg: bool,
                 ) -> f32 {
                     if mg_eg {
                         TAPERED_MG_PESTO[piece_type.to_index()][location]
                     } else {
                         TAPERED_EG_PESTO[piece_type.to_index()][location]
                     }
                 }
-                let moved_piece_type= board.piece_on(chess_move.get_source()).unwrap();
+                let moved_piece_type = board.piece_on(chess_move.get_source()).unwrap();
 
                 let multiplier = if board.side_to_move() == Color::White {
                     1
@@ -264,7 +264,6 @@ impl Algorithm {
                         mg_incremental_psqt_eval_change += Self::calc_tapered_psqt_eval(board, i, true);
                         mg_incremental_psqt_eval_change += Self::calc_tapered_psqt_eval(board, i, false);
                     }
-
                 } else {
                     //Remove the eval from the previous square we stood on.
                     let source: usize = (56 - chess_move.get_source().to_int()
@@ -277,8 +276,8 @@ impl Algorithm {
                     let dest: usize = (56 - chess_move.get_dest().to_int()
                         + 2 * (chess_move.get_dest().to_int() % 8))
                         as usize;
-                        mg_incremental_psqt_eval_change += calc_increment(moved_piece_type, dest, true);
-                        eg_incremental_psqt_eval_change += calc_increment(moved_piece_type, dest, false);
+                    mg_incremental_psqt_eval_change += calc_increment(moved_piece_type, dest, true);
+                    eg_incremental_psqt_eval_change += calc_increment(moved_piece_type, dest, false);
 
                     //Decrement enemy eval from potetntial capture
                     if let Some(attacked_piece_type) = board.piece_on(chess_move.get_dest()) {
@@ -289,8 +288,8 @@ impl Algorithm {
                 mg_incremental_psqt_eval += mg_incremental_psqt_eval_change * multiplier as f32;
                 eg_incremental_psqt_eval += eg_incremental_psqt_eval_change * multiplier as f32;
             }
-            best_evaluation.incremental_psqt_eval = 
-            Some(mg_incremental_psqt_eval + eg_incremental_psqt_eval);
+            best_evaluation.incremental_psqt_eval =
+                Some(mg_incremental_psqt_eval + eg_incremental_psqt_eval);
         }
 
         if module_enabled(self.modules, TRANSPOSITION_TABLE) && depth >= 3 {
@@ -320,7 +319,7 @@ impl Algorithm {
         board: &Board,
         depth: u32,
         deadline: Option<Instant>,
-    ) -> (Option<chess::Action>, Vec<String>, Stats) {
+    ) -> (Option<Action>, Vec<String>, Stats) {
         let mut stats = Stats::default();
         let out = self.node_eval_recursive(
             board,
@@ -343,7 +342,7 @@ impl Algorithm {
         &mut self,
         board: &Board,
         deadline: Instant,
-    ) -> (chess::Action, Vec<String>, Stats) {
+    ) -> (Action, Vec<String>, Stats) {
         self.board_played_times.insert(
             *board,
             *self.board_played_times.get(board).unwrap_or(&0) + 1,
@@ -401,7 +400,7 @@ impl Algorithm {
         board: &Board,
         board_played_times_prediction: &HashMap<Board, u32>,
         mg_incremental_psqt_eval: f32,
-        eg_incremental_psqt_eval: f32
+        eg_incremental_psqt_eval: f32,
     ) -> f32 {
         let board_status = board.status();
         if board_status == BoardStatus::Stalemate {
@@ -426,7 +425,7 @@ impl Algorithm {
         let diff_material: i32 = material_each_side.0 as i32 - material_each_side.1 as i32;
 
         let mut controlled_squares = 0;
-        if utils::module_enabled(self.modules, modules::SQUARE_CONTROL_METRIC) {
+        if module_enabled(self.modules, SQUARE_CONTROL_METRIC) {
             controlled_squares = if board.side_to_move() == Color::Black {
                 -1i32
             } else {
@@ -436,7 +435,7 @@ impl Algorithm {
 
         // Compares piece position with an 8x8 table containing certain values. The value corresponding to the position of the piece gets added as evaluation.
         let mut naive_psqt: f32 = 0.;
-        if utils::module_enabled(self.modules, modules::NAIVE_PSQT) {
+        if module_enabled(self.modules, NAIVE_PSQT) {
             fn naive_psqt_calc(
                 naive_psqt_table: [f32; 64],
                 piece_bitboard: &BitBoard,
@@ -503,18 +502,18 @@ impl Algorithm {
         let mut mg_tapered_pesto: f32 = 0.;
         let mut eg_tapered_pesto: f32 = 0.;
         let mut tapered_pesto: f32 = 0.;
-        if utils::module_enabled(self.modules, modules::TAPERED_EVERY_PESTO_PSQT) {
+        if module_enabled(self.modules, TAPERED_EVERY_PESTO_PSQT) {
             for i in 0..5 {
                 mg_tapered_pesto += Self::calc_tapered_psqt_eval(board, i, true);
                 eg_tapered_pesto += Self::calc_tapered_psqt_eval(board, i, false);
             }
-            tapered_pesto = ((material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King)) as f32 * mg_tapered_pesto + 
-            (78 - (material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King))) as f32 * eg_tapered_pesto)
-            / 78.;
+            tapered_pesto = ((material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King)) as f32 * mg_tapered_pesto +
+                (78 - (material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King))) as f32 * eg_tapered_pesto)
+                / 78.;
         }
 
         let mut pawn_structure: f32 = 0.;
-        if utils::module_enabled(self.modules, modules::PAWN_STRUCTURE) {
+        if module_enabled(self.modules, PAWN_STRUCTURE) {
             fn pawn_structure_calc(
                 all_pawn_bitboard: &BitBoard,
                 color_bitboard: &BitBoard,
@@ -526,15 +525,15 @@ impl Algorithm {
                 //pawn chain, awarding 0.5 eval for each pawn protected by another pawn. Constants should in theory cover an (literal) edge case... I hope.
                 bonus += 0.5
                     * ((pawn_bitboard & 0xFEFEFEFEFEFEFEFE & (pawn_bitboard << 9)).count_ones()
-                        + (pawn_bitboard & 0x7F7F7F7F7F7F7F7F & (pawn_bitboard << 7)).count_ones())
-                        as f32;
+                    + (pawn_bitboard & 0x7F7F7F7F7F7F7F7F & (pawn_bitboard << 7)).count_ones())
+                    as f32;
 
                 //stacked pawns. -0.5 points per rank containing >1 pawns. By taking the pawn bitboard and operating bitwise AND for another bitboard (integer) where the leftmost rank is filled. This returns all pawns in that rank. By bitshifting we can choose rank. Additionally by counting we get number of pawns. We then remove 1 as we only want to know if there are >1 pawn. If there is, subtract 0.5 points per extra pawn.
                 for i in 0..7 {
                     //constant 0x8080808080808080: entire first rank.
                     bonus -= 0.5
                         * ((pawn_bitboard & (0x8080808080808080 >> i)).count_ones() as f32 - 1.)
-                            .max(0.);
+                        .max(0.);
                 }
 
                 //king safety. Outer 3 pawns get +1 eval bonus per pawn if king is behind them. King bitboard required is either ..X..... or ......X.
@@ -558,9 +557,9 @@ impl Algorithm {
         }
 
         let mut incremental_psqt_eval: f32 = 0.;
-        if utils::module_enabled(self.modules, modules::TAPERED_INCREMENTAL_PESTO_PSQT) {
+        if module_enabled(self.modules, TAPERED_INCREMENTAL_PESTO_PSQT) {
             incremental_psqt_eval = (material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King)) as f32 * mg_incremental_psqt_eval
-                                  + (78 - material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King)) as f32 * eg_incremental_psqt_eval
+                + (78 - material_each_side.0 + material_each_side.1 - 2 * piece_value(Piece::King)) as f32 * eg_incremental_psqt_eval
         }
 
         let evaluation: f32 = controlled_squares as f32 / 20.
@@ -577,7 +576,7 @@ impl Algorithm {
             piece_bitboard: &BitBoard,
             color_bitboard: &BitBoard,
             piece_index: usize,
-            mg_eg: bool
+            mg_eg: bool,
         ) -> f32 {
             // Essentially, gets the dot product between a "vector" of the bitboard (containing 64 0s and 1s) and the table with NAIVE_PSQT bonus constants.
             let mut bonus: f32 = 0.;
@@ -592,22 +591,21 @@ impl Algorithm {
                     // and we (hopefully?) linerarly transition from one to the other, depending on material value.
                     bonus += ((piece_bitboard & color_bitboard)
                         .reverse_colors()
-                        .to_size(i as u8) & 1) as f32 
+                        .to_size(i as u8) & 1) as f32
                         * TAPERED_MG_PESTO[piece_index][i];
                 }
                 bonus
             } else {
                 for i in 0..63 {
                     bonus += ((piece_bitboard & color_bitboard)
                         .reverse_colors()
-                        .to_size(i as u8) & 1) as f32 
+                        .to_size(i as u8) & 1) as f32
                         * TAPERED_EG_PESTO[piece_index][i];
                 }
                 bonus
             }
-
         }
-    
+
         macro_rules! tapered_psqt_calc {
             ($board: tt, $piece: tt, $index: tt, $mg_eg: tt) => {
                 tapered_psqt_calc(
@@ -627,7 +625,6 @@ impl Algorithm {
             5 => tapered_psqt_calc!(board, King, 5, mg_eg),
             6_u8..=u8::MAX => unimplemented!()
         }
-
     }
 
     pub(crate) fn reset(&mut self) {

Diff for: src/common/utils.rs

@@ -110,6 +110,8 @@ impl AddAssign for Stats {
 }
 
 impl Div<u32> for Stats {
+    type Output = StatsAverage;
+
     fn div(self, rhs: u32) -> Self::Output {
         StatsAverage {
             alpha_beta_breaks: self.alpha_beta_breaks as f32 / rhs as f32,
@@ -126,8 +128,6 @@ impl Div<u32> for Stats {
             tt_size: self.tt_size as f32 / rhs as f32,
         }
     }
-
-    type Output = StatsAverage;
 }
 #[derive(Default, Debug)]
 // These fields are used through Debug

Diff for: src/pitter/logic.rs

@@ -242,7 +242,7 @@ impl Competition {
                 );
 
                 //Whether the game just played should be printed in console.
-                if PRINT_GAME == true {
+                if PRINT_GAME {
                     println!("Game pair played.  Outcome: {:?}", combined_outcome);
                     println!("{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
                 }