Now prints results to file instead of terminal

Also added som preliminary parts to begin with a bigger test.

Author: LelleSwe

Cargo.lock

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use chess::{Action, BitBoard, Board, BoardStatus, ChessMove, Color, MoveGen, Piece};
+use serde::{Deserialize, Serialize};
 use tokio::time::{Duration, Instant};
 
 use crate::algorithms::{draw_checker, eval};
@@ -13,6 +14,7 @@ use crate::modules::{alpha_beta, analyze};
 
 use super::utils::Evaluation;
 
+
 #[derive(Clone, Debug)]
 pub(crate) struct Algorithm {
     pub(crate) modules: u32,

src/algorithms/the_algorithm.rs

@@ -0,0 +1,37 @@
+use std::{fs::OpenOptions, io::{self, prelude::*}};
+
+pub(crate) fn write_result(buf: &[u8], file: &str) -> std::io::Result<()> {
+    let mut file = OpenOptions::new().write(true).create(true).append(true).open(file).unwrap();
+    file.write(buf)?;
+    Ok(())
+}
+
+pub(crate)fn modules_to_string(modules: u32) -> String {
+    let mut start: bool = true;
+    let mut output: String = "".to_string();
+    //For loop ranges is all available modules index. +1 because we need inclusive.
+    for i in 0..9+1 {
+        if (modules & (1 << i)).count_ones() == 1 {
+            let module_string = match i {
+                0 => "ANALYZE",
+                1 => "ALPHA_BETA",
+                2 => "TRANSPOSITION_TABLE",
+                3 => "SEARCH_EXTENSIONS",
+                4 => "SQUARE_CONTROL_METRIC",
+                5 => "SKIP_BAD_MOVES",
+                6 => "NAIVE_PSQT",
+                7 => "PAWN_STRUCTURE",
+                8 => "TAPERED_EVERY_PESTO_PSQT",
+                9 => "TAPERED_INCREMENTAL_PESTO_PSQT",
+                _ => "INVALID MODULE DETECTED"
+            };
+            if !start {
+                output = output + &", " + module_string;
+            } else {
+                start = false;
+                output = module_string.to_string();
+            }
+        }
+    }
+    output
+}

src/io.rs

@@ -1,32 +1,66 @@
 use std::time::Duration;
 
+
 use crate::algorithms::the_algorithm::Algorithm;
 #[allow(unused_imports)]
 use crate::common::constants::modules::{
     ALPHA_BETA, ANALYZE, NAIVE_PSQT, PAWN_STRUCTURE, SEARCH_EXTENSIONS, SKIP_BAD_MOVES,
     SQUARE_CONTROL_METRIC, TAPERED_EVERY_PESTO_PSQT, TAPERED_INCREMENTAL_PESTO_PSQT,
     TRANSPOSITION_TABLE,
 };
+use crate::io::{write_result, modules_to_string};
 
-use self::pitter::logic::Competition;
+use self::pitter::logic::{Competition, CompetitionResults};
 
 mod algorithms;
 mod common;
 mod modules;
 mod pitter;
+mod io;
 
 //If we should print the moves played and results of each game.
 pub(crate) const PRINT_GAME: bool = false;
 
 #[tokio::main]
 async fn main() {
-    //ALPHA_BETA | ANALYZE | SEARCH_EXTENSIONS | SKIP_BAD_MOVES | SQUARE_CONTROL_METRIC | TRANSPOSITION_TABLE | NAIVE_PSQT | PAWN_STRUCTURE | TAPERED_EVERY_PESTO_PSQT | TAPERED_INCREMENTAL_PESTO_PSQT
-    //Put 0 for no modules.
-    let modules1 = ALPHA_BETA | TAPERED_EVERY_PESTO_PSQT;
-    let modules2 = ALPHA_BETA;
-    let time_per_move1 = Duration::from_micros(4000);
-    let time_per_move2 = Duration::from_micros(2000);
+    if !TEST_SEVERAL {
+        //ALPHA_BETA | ANALYZE | SEARCH_EXTENSIONS | SKIP_BAD_MOVES | SQUARE_CONTROL_METRIC | TRANSPOSITION_TABLE | NAIVE_PSQT | PAWN_STRUCTURE | TAPERED_EVERY_PESTO_PSQT | TAPERED_INCREMENTAL_PESTO_PSQT
+        //Put 0 for no modules.
+        //Setup modules
+        let modules1 = ALPHA_BETA | TAPERED_INCREMENTAL_PESTO_PSQT;
+        let modules2 = ALPHA_BETA | TAPERED_EVERY_PESTO_PSQT;
+        let time_per_move1 = Duration::from_micros(2000);
+        let time_per_move2 = Duration::from_micros(2000);
+        let game_pairs = 500;
+
+        //Run competition
+        let result = do_competition(modules1, modules2, time_per_move1, time_per_move2, game_pairs).await;
+        
+        //Save results to file
+        let mut output: String = "Algo 1 modules: ".to_owned() + &modules_to_string(modules1) + "\nAlgo 2 modules: " + &modules_to_string(modules2);
+        let result = format!("\nCompetition results: {:#?}", &result);
+        output = output + &result;
+        let buf = output.as_bytes();
+        let _ = write_result(buf, "./output.txt");
+
+    } else {
+        /*let time_per_move1 = Duration::from_micros(2000);
+        let time_per_move2 = Duration::from_micros(2000);
+        
+        let mut modules1 = 1;
+        let mut modules2 = 1;
+
+        for i in 0..log2() {
+            for j in 0.. {
+
+            }
+        }*/
+    }
+    
+}
 
+const TEST_SEVERAL: bool = false;
+async fn do_competition(modules1: u32, modules2: u32, time_per_move1: Duration, time_per_move2: Duration, game_pairs: u32) -> CompetitionResults {
     let competition = Competition::new(
         Algorithm::new(modules1, time_per_move1),
         Algorithm::new(modules2, time_per_move2),
@@ -35,6 +69,6 @@ async fn main() {
     // competition.analyze_algorithm_choices(|(game_info, _), _| {
     //     game_info.outcome == GameOutcome::InconclusiveTooLong
     // });
-    let results = competition.start_competition(1000).await;
-    dbg!(results);
+    let results = competition.start_competition(game_pairs).await;
+    results
 }

src/main.rs

@@ -5,9 +5,12 @@ use tokio::time::{Duration, Instant};
 use chess::{Action, Board, Color, Game, GameResult};
 use tokio::sync::Mutex;
 
+use serde::{Serialize, Deserialize};
+
 use crate::algorithms::the_algorithm::Algorithm;
 use crate::common::constants::modules::ANALYZE;
 use crate::common::utils::{self, Stats};
+use crate::io::write_result;
 use crate::PRINT_GAME;
 
 pub(crate) struct Competition {
@@ -62,7 +65,7 @@ pub(crate) enum GameOutcome {
 }
 
 #[allow(unused_assignments)]
-#[derive(Default, Debug, Copy, Clone)]
+#[derive(Default, Debug, Copy, Clone, Serialize, Deserialize)]
 pub(crate) struct CompetitionResults {
     /// How many pairs of games that Algo1 wins from both positions
     algo1_wins: usize,
@@ -270,8 +273,19 @@ impl Competition {
             sum_stats.1 / sum_stats.1.num_plies,
         );
 
-        println!("Stats for algo1: {:#?}", avg_stats.0);
-        println!("Stats for algo2: {:#?}", avg_stats.1);
+        //I don't know why I have to do this middle step terribleness, 
+        //but for some reason it won't compile otherwise.
+        let algo1stats = format!("\nStats for algo1: {:#?}", avg_stats.0);
+        let algo1stats = algo1stats.as_bytes();
+        let algo2stats = format!("Stats for algo2: {:#?}", avg_stats.1);
+        let algo2stats = algo2stats.as_bytes();
+        
+        //Marking that the result from these calls won't be used.
+        let _ = crate::io::write_result(algo1stats, "./output.txt");
+        let _ = crate::io::write_result(algo2stats, "./output.txt");
+
+        //println!("Stats for algo1: {:#?}", avg_stats.0);
+        //println!("Stats for algo2: {:#?}", avg_stats.1);
 
         // Gives E0597 otherwise
         #[allow(clippy::let_and_return)]
@@ -359,7 +373,7 @@ impl Competition {
             i += 1;
         }
 
-        dbg!(&self.algo1.board_played_times.values());
-        dbg!(&self.algo2.board_played_times.values());
+        /*let _ = write_result(stringify!(&self.algo1.board_played_times.values()).as_bytes(), "./output.txt");
+        let _ = write_result(stringify!(&self.algo2.board_played_times.values()).as_bytes(), "./output.txt");*/
     }
 }