Four types of playouts

Author: ujh

src/board/mod.rs

@@ -264,27 +264,6 @@ impl Board {
         }
     }
 
-    pub fn playout_move(&self, rng: &mut XorShiftRng) -> Move {
-            let color = self.next_player();
-            let vacant = self.vacant();
-            if vacant
-                .iter()
-                .map(|coord| Play(color, coord.col, coord.row))
-                .any(|m| !self.is_eye(&m.coord(), *m.color()) && self.is_legal(m).is_ok() ) {
-                    //while loop testing all vacant spots
-                    loop {
-                        let random_vacant = vacant[rng.gen::<usize>() % vacant.len()];
-                        let random_play = Play(color, random_vacant.col, random_vacant.row);
-                        if !self.is_eye(&random_vacant, color) && self.is_legal(random_play).is_ok() {
-                            return random_play;
-                        }
-                    }
-                } else {
-                    let color = self.next_player();
-                    Pass(color)
-                }
-	}
-
     //#[inline(never)] //turn off for profiling
     pub fn legal_moves_without_eyes(&self) -> Vec<Move> {
         self.legal_moves_without_superko_check()

src/board/test/mod.rs

@@ -494,15 +494,3 @@ fn adv_stones_removed_only_contains_each_coord_once() {
     removed_coords.dedup();
     assert_eq!(removed_coords.len(), board.adv_stones_removed().len());
 }
-
-#[test]
-fn random_playout_moves_should_be_legal() {
-    let parser = Parser::from_path(Path::new("fixtures/sgf/recapture-but-not-ko.sgf"));
-    let game = parser.game().unwrap();
-    let board = game.board();
-    let mut rng = weak_rng();
-    for _ in 0..10 {
-    	let m = board.playout_move(&mut rng);
-    	assert!(board.is_legal(m).is_ok());
-    }
-}

src/engine/mc/mod.rs

@@ -125,7 +125,7 @@ fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves:
         loop {
             for _ in 0..runs {
                 let m = moves[rng.gen::<usize>() % moves.len()];
-                let playout_result = config.playout.run(&board, &m, &mut rng);
+                let playout_result = config.playout.run(&board, &m);
                 let winner = playout_result.winner();
                 T::record_playout(&mut stats, &playout_result, winner == color);
             }

src/main.rs

@@ -74,7 +74,7 @@ pub fn main() {
     opts.optopt("e", "engine", "select an engine (defaults to amaf)", "amaf|mc|random");
     opts.optopt("r", "ruleset", "select the ruleset (defaults to chinese)", "cgos|chinese|tromp-taylor|minimal");
     opts.optopt("t", "threads", "number of threads to use (defaults to 1)", "NUM");
-    opts.optopt("p", "playout", "type of playout to use (defaults to no-eyes)", "no-eyes|simple");
+    opts.optopt("p", "playout", "type of playout to use (defaults to no-eyes)", "no-eyes|no-eyes-with-pass|simple|simple-with-pass");
     opts.optflag("h", "help", "print this help menu");
     opts.optflag("v", "version", "print the version number");
     opts.optflag("l", "log", "log to stderr (defaults to false)");

src/playout/mod.rs

@@ -20,12 +20,16 @@
  ************************************************************************/
 
 pub use self::no_eyes::NoEyesPlayout;
+pub use self::no_eyes::NoEyesWithPassPlayout;
 pub use self::simple::SimplePlayout;
+pub use self::simple::SimpleWithPassPlayout;
 use board::Board;
-use board::Move;
 use board::Color;
+use board::Move;
+use board::Pass;
+use board::Play;
 
-use rand::XorShiftRng;
+use rand::random;
 
 mod no_eyes;
 mod simple;
@@ -35,43 +39,76 @@ pub fn factory(opt: Option<String>) -> Box<Playout> {
     match opt {
         Some(s) => {
             match s.as_slice() {
+                "no-eyes-with-pass" => Box::new(NoEyesWithPassPlayout::new()),
                 "simple" => Box::new(SimplePlayout::new()),
+                "simple-with-pass" => Box::new(SimpleWithPassPlayout::new()),
                 _ => Box::new(NoEyesPlayout::new()),
             }
         },
         None => Box::new(NoEyesPlayout::new())
     }
 }
 
-
 pub trait Playout: Sync + Send {
 
-    fn run(&self, b: &Board, initial_move: &Move, rng: &mut XorShiftRng) -> PlayoutResult {
+    fn run(&self, b: &Board, initial_move: &Move) -> PlayoutResult {
         let mut board = b.clone();
         let mut played_moves = Vec::new();
         board.play(*initial_move);
         played_moves.push(*initial_move);
         let max_moves = self.max_moves(board.size());
         let mut move_count = 0;
         while !board.is_game_over() && move_count < max_moves {
-            let m = board.playout_move(rng);
+            let m = self.select_move(&board);
             board.play(m);
             played_moves.push(m);
             move_count += 1;
         }
         PlayoutResult::new(played_moves, board.winner())
     }
 
-    fn moves(&self, b: &Board) -> Vec<Move>;
+    fn is_playable(&self, board: &Board, m: &Move) -> bool;
+    fn include_pass(&self) -> bool;
 
     fn max_moves(&self, size: u8) -> usize {
         size as usize * size as usize * 3
     }
 
+    fn select_move(&self, board: &Board) -> Move {
+        let color = board.next_player();
+        let vacant = board.vacant();
+        let playable_move_exists =  vacant
+            .iter()
+            .map(|c| Play(color, c.col, c.row))
+            .any(|m| board.is_legal(m).is_ok() && self.is_playable(board, &m));
+        if playable_move_exists {
+            loop {
+                let add = if self.include_pass() {
+                    1
+                } else {
+                    0
+                };
+                let r = random::<usize>() % (vacant.len() + add);
+                if r == vacant.len() {
+                    return Pass(color);
+                } else {
+                    let c = vacant[r];
+                    let m = Play(color, c.col, c.row);
+                    if board.is_legal(m).is_ok() && self.is_playable(board, &m) {
+                        return m;
+                    }
+                }
+            }
+        } else {
+            Pass(color)
+        }
+    }
+
     fn playout_type(&self) -> String;
 
 }
 
+#[derive(Debug)]
 pub struct PlayoutResult {
     moves: Vec<Move>,
     winner: Color,

src/playout/no_eyes.rs

@@ -36,8 +36,39 @@ impl NoEyesPlayout {
 
 impl Playout for NoEyesPlayout {
 
-    fn moves(&self, b: &Board) -> Vec<Move> {
-        b.legal_moves_without_eyes()
+    fn is_playable(&self, board: &Board, m: &Move) -> bool {
+        !board.is_eye(&m.coord(), *m.color())
+    }
+
+    fn include_pass(&self) -> bool {
+        false
+    }
+
+    fn playout_type(&self) -> String {
+        format!("{:?}", self)
+    }
+
+}
+
+#[derive(Debug)]
+pub struct NoEyesWithPassPlayout;
+
+impl NoEyesWithPassPlayout {
+
+    pub fn new() -> NoEyesWithPassPlayout {
+        NoEyesWithPassPlayout
+    }
+
+}
+
+impl Playout for NoEyesWithPassPlayout {
+
+    fn is_playable(&self, board: &Board, m: &Move) -> bool {
+        !board.is_eye(&m.coord(), *m.color())
+    }
+
+    fn include_pass(&self) -> bool {
+        true
     }
 
     fn playout_type(&self) -> String {

src/playout/simple.rs

@@ -36,8 +36,38 @@ impl SimplePlayout {
 
 impl Playout for SimplePlayout {
 
-    fn moves(&self, b: &Board) -> Vec<Move> {
-        b.legal_moves_without_superko_check()
+    fn is_playable(&self, _: &Board, _: &Move) -> bool {
+        true
+    }
+
+    fn include_pass(&self) -> bool {
+        false
+    }
+
+    fn playout_type(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
+#[derive(Debug)]
+pub struct SimpleWithPassPlayout;
+
+impl SimpleWithPassPlayout {
+
+    pub fn new() -> SimpleWithPassPlayout {
+        SimpleWithPassPlayout
+    }
+
+}
+
+impl Playout for SimpleWithPassPlayout {
+
+    fn is_playable(&self, _: &Board, _: &Move) -> bool {
+        true
+    }
+
+    fn include_pass(&self) -> bool {
+        true
     }
 
     fn playout_type(&self) -> String {

src/playout/test/mod.rs

@@ -31,13 +31,25 @@ fn factory_returns_no_eyes_by_default() {
 }
 
 #[test]
-fn factory_returns_simple_when_given_simple() {
+fn factory_returns_simple() {
     let playout = super::factory(Some(String::from_str("simple")));
     assert_eq!("SimplePlayout", playout.playout_type());
 }
 
+#[test]
+fn factory_returns_simple_with_pass() {
+    let playout = super::factory(Some(String::from_str("simple-with-pass")));
+    assert_eq!("SimpleWithPassPlayout", playout.playout_type());
+}
+
 #[test]
 fn factroy_returns_no_eyes_when_given_any_string() {
     let playout = super::factory(Some(String::from_str("foo")));
     assert_eq!("NoEyesPlayout", playout.playout_type());
 }
+
+#[test]
+fn factory_returns_no_eyes_with_pass() {
+    let playout = super::factory(Some(String::from_str("no-eyes-with-pass")));
+    assert_eq!("NoEyesWithPassPlayout", playout.playout_type());
+}

src/playout/test/no_eyes.rs

@@ -25,18 +25,17 @@ use board::Black;
 use board::Board;
 use board::Play;
 use playout::NoEyesPlayout;
+use playout::NoEyesWithPassPlayout;
 use playout::Playout;
 use ruleset::KgsChinese;
 
-use rand::weak_rng;
 use test::Bencher;
 
 #[test]
 fn should_add_the_passed_moves_as_the_first_move() {
     let board = Board::new(9, 6.5, KgsChinese);
-    let mut rng = weak_rng();
     let playout = NoEyesPlayout::new();
-    let result = playout.run(&board, &Play(Black, 1, 1), &mut rng);
+    let result = playout.run(&board, &Play(Black, 1, 1));
     assert_eq!(Play(Black, 1, 1), result.moves()[0]);
 }
 
@@ -47,25 +46,43 @@ fn max_moves() {
 }
 
 #[bench]
-fn bench_9x9_playout_speed(b: &mut Bencher) {
+fn no_eyes_09x09(b: &mut Bencher) {
     let board = Board::new(9, 6.5, KgsChinese);
-    let mut rng = weak_rng();
     let playout = NoEyesPlayout::new();
-    b.iter(|| playout.run(&board, &Play(Black, 1, 1), &mut rng))
+    b.iter(|| playout.run(&board, &Play(Black, 1, 1)))
 }
 
 #[bench]
-fn bench_13x13_playout_speed(b: &mut Bencher) {
+fn no_eyes_13x13(b: &mut Bencher) {
     let board = Board::new(13, 6.5, KgsChinese);
-    let mut rng = weak_rng();
     let playout = NoEyesPlayout::new();
-    b.iter(|| playout.run(&board, &Play(Black, 1, 1), &mut rng))
+    b.iter(|| playout.run(&board, &Play(Black, 1, 1)))
 }
 
 #[bench]
-fn bench_19x19_playout_speed(b: &mut Bencher) {
+fn no_eyes_19x19(b: &mut Bencher) {
     let board = Board::new(19, 6.5, KgsChinese);
-    let mut rng = weak_rng();
     let playout = NoEyesPlayout::new();
-    b.iter(|| playout.run(&board, &Play(Black, 1, 1), &mut rng))
+    b.iter(|| playout.run(&board, &Play(Black, 1, 1)))
+}
+
+#[bench]
+fn with_pass_09x09(b: &mut Bencher) {
+    let board = Board::new(9, 6.5, KgsChinese);
+    let playout = NoEyesWithPassPlayout::new();
+    b.iter(|| playout.run(&board, &Play(Black, 1, 1)))
+}
+
+#[bench]
+fn with_pass_13x13(b: &mut Bencher) {
+    let board = Board::new(13, 6.5, KgsChinese);
+    let playout = NoEyesWithPassPlayout::new();
+    b.iter(|| playout.run(&board, &Play(Black, 1, 1)))
+}
+
+#[bench]
+fn with_pass_19x19(b: &mut Bencher) {
+    let board = Board::new(19, 6.5, KgsChinese);
+    let playout = NoEyesWithPassPlayout::new();
+    b.iter(|| playout.run(&board, &Play(Black, 1, 1)))
 }