s

src/elo.rs

@@ -1,9 +1,9 @@
 use crate::{
-    agent::{Agent, RandomAgent},
+    agent::Agent,
     complexagent::ComplexAgent,
     game_inner::GameInner,
     logic::FutureMoveConfig,
-    repr::{Piece, Winner},
+    repr::{Board, Piece, Winner},
 };
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use skillratings::{
@@ -17,16 +17,16 @@ pub fn run() {
         min_arena_depth: 14,
         top_k_children: 2,
         up_to_minus: 10,
-        max_arena_size: 5_000_000,
+        max_arena_size: usize::MAX,
-        do_not_prune: false,
+        do_not_prune: true,
         print: false,
     };
 
     let mut arena = PlayerArena::new(vec![
-        (
+        // (
-            "RandomAgent".into(),
+        //     "RandomAgent".into(),
-            Box::new(|piece| Box::new(RandomAgent::new(piece))),
+        //     Box::new(|piece| Box::new(RandomAgent::new(piece))),
-        ),
+        // ),
         (
             "ComplexAgentD1".into(),
             Box::new(|piece| {
@@ -39,18 +39,6 @@ pub fn run() {
                 ))
             }),
         ),
-        (
-            "ComplexAgentD2".into(),
-            Box::new(|piece| {
-                Box::new(ComplexAgent::new(
-                    piece,
-                    FutureMoveConfig {
-                        max_depth: 2,
-                        ..FMV_BASE
-                    },
-                ))
-            }),
-        ),
         (
             "ComplexAgentD3".into(),
             Box::new(|piece| {
@@ -64,32 +52,46 @@ pub fn run() {
             }),
         ),
         (
-            "ComplexAgentD4".into(),
+            "ComplexAgentD8".into(),
             Box::new(|piece| {
                 Box::new(ComplexAgent::new(
                     piece,
                     FutureMoveConfig {
-                        max_depth: 4,
+                        max_depth: 8,
                         ..FMV_BASE
                     },
                 ))
             }),
         ),
+        // (
+        //     "ComplexAgent5M".into(),
+        //     Box::new(|piece| {
+        //         Box::new(ComplexAgent::new(
+        //             piece,
+        //             FutureMoveConfig {
+        //                 max_arena_size: 5_000_000,
+        //                 ..FMV_BASE
+        //             },
+        //         ))
+        //     }),
+        // ),
     ]);
 
-    arena.play(
+    // arena.play(
-        &(0..arena.players.len())
+    //     &(0..arena.players.len())
-            .zip([0].into_iter().cycle())
+    //         .zip([0].into_iter().cycle())
-            .filter(|(i, j)| i != j)
+    //         .filter(|(i, j)| i != j)
-            .collect::<Vec<_>>()
+    //         .collect::<Vec<_>>()
-            .repeat(1000),
+    //         .repeat(1000),
-    );
+    // );
-
+    for _ in 0..10 {
+        arena.prop_arena(2);
         println!("{}", arena);
     }
+}
 
 pub struct PlayerArena {
-    /// Name, Creator, Elo
+    /// Name, Creator Function, Elo
     players: Vec<(String, Box<dyn Fn(Piece) -> Box<dyn Agent>>, EloRating)>,
 }
 
@@ -124,7 +126,7 @@ impl PlayerArena {
 
     fn play(&mut self, pairs: &[(usize, usize)]) {
         pairs
-            .into_iter()
+            .iter()
             .map(|&(i, j)| {
                 (
                     (i, j),
@@ -141,7 +143,7 @@ impl PlayerArena {
             .for_each(|(i, j, o)| self.process_outcome(i, j, &o));
     }
 
-    fn prop_arena(&mut self) {
+    fn prop_arena(&mut self, n: usize) {
         self.play(
             &(0..self.players.len())
                 .flat_map(|i| {
@@ -150,7 +152,8 @@ impl PlayerArena {
                         .filter(|(i, j)| i != j)
                         .collect::<Vec<_>>()
                 })
-                .collect::<Vec<_>>(),
+                .collect::<Vec<_>>()
+                .repeat(n),
         );
     }
 
@@ -173,7 +176,8 @@ impl PlayerArena {
     }
 
     fn play_two_inner(player_1: Box<dyn Agent>, player_2: Box<dyn Agent>) -> Outcomes {
-        let result = GameInner::new(player_1, player_2, false).loop_until_result();
+        let result =
+            GameInner::new(player_1, player_2, false, Board::random(5)).loop_until_result();
 
         match result {
             Winner::Player(piece) => match piece {

src/game.rs

@@ -1,7 +1,4 @@
-use crate::{
+use crate::{agent::Agent, game_inner::GameInner, repr::Board};
-    agent::Agent,
-    game_inner::GameInner,
-};
 
 pub struct Game {
     inner: GameInner,
@@ -11,7 +8,7 @@ pub struct Game {
 impl Game {
     pub fn new(player1: Box<dyn Agent>, player2: Box<dyn Agent>) -> Self {
         Self {
-            inner: GameInner::new(player1, player2, true),
+            inner: GameInner::new(player1, player2, true, Board::new().starting_pos()),
         }
     }
 

src/game_inner.rs

@@ -25,7 +25,12 @@ pub struct GameInner {
 }
 
 impl GameInner {
-    pub fn new(player1: Box<dyn Agent>, player2: Box<dyn Agent>, do_print: bool) -> Self {
+    pub fn new(
+        player1: Box<dyn Agent>,
+        player2: Box<dyn Agent>,
+        do_print: bool,
+        board: Board,
+    ) -> Self {
         let player1_color = player1.color();
         let player2_color = player2.color();
         assert_ne!(
@@ -40,7 +45,7 @@ impl GameInner {
 
         Self {
             players: [player1, player2],
-            board: Board::new().starting_pos(),
+            board,
             do_print,
         }
     }

src/repr/board.rs

@@ -5,7 +5,7 @@ use super::{
     CoordAxis, CoordPair,
 };
 use const_fn::const_fn;
-use rand::{seq::IteratorRandom, Rng};
+use rand::seq::IteratorRandom;
 use std::{cmp::Ordering, fmt, sync::LazyLock};
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]