Merge pull request #131 from iopq/playout

Playout without self-atari of large chains

Author: iopq

fixtures/sgf/hypothetical-plays.sgf

@@ -0,0 +1,5 @@
+(;FF[4]CA[UTF-8]AP[GoGui:1.4.9]
+KM[7.5]DT[2015-04-04]
+AB[ba][bb][cb][cd][be][cf][dg][ef][ci][bj][ck][dl][ek][fj][ei][dn][co][bp][cq][dr][eq][fp][eo][hc][ic][jc][kb][ka][gc][gb][ga][kd][ke][hd][he][hf][if][jf][ih][ij][kj][im][jl][km][ip][jo][kp][jq][nc][nb][ob][pc][od][ng][nf][of][pg][ph][oh][nj][oj][pj][pk][pl][ol][nl][nk]
+AW[ca][db][eb][ea][ce][df][cj][dk][ej][do][cp][dq][ep][ia][ja][jb][ha][hb][id][jd][je]
+)

src/board/mod.rs

@@ -563,6 +563,45 @@ impl Board {
         self.board[c.to_index(self.size)].chain_id = -1;
         self.board[c.to_index(self.size)].color = Empty;
     }
+    
+    pub fn liberty_count(&self, c: Coord) -> usize {
+        self.neighbours(c).iter().filter(|c| self.color(c) == Empty).count()
+    }
+    
+    pub fn removes_enemy_neighbouring_stones(&self, m: Move) -> usize {
+        let enemy = m.color().opposite();
+        self.neighbours(m.coord()).iter()                           //for all neighbours
+            .filter(|c| {                                           //take only
+                self.color(c) == enemy &&                           //the enemy stones
+                self.get_chain(**c).unwrap().liberties().len() == 1 //that have 1 liberty
+            })
+            .count()
+    }
+    
+    pub fn new_chain_liberties(&self, m: Move) -> usize {
+        let mut set: HashSet<Coord> = HashSet::new();
+        
+        for &c in self.neighbours(m.coord()).iter() {
+            if(self.color(&c) == *m.color()) {
+                //add the liberties the chain
+                for &liberty in self.get_chain(c).unwrap().liberties() {
+                    set.insert(liberty);
+                }
+            } else if(self.color(&c) == Empty)  {
+                set.insert(c);
+            }
+        };
+        set.len() - 1 //minus the stone we're about to play
+    }
+    
+    //the length of all merged chains after the current move
+    pub fn new_chain_length(&self, m: Move) -> usize {
+        let set: HashSet<&Coord> = self.neighbours(m.coord()).iter()
+            .filter(|c| self.color(c) == *m.color())
+            .flat_map(|c| self.get_chain(*c).unwrap().coords().iter())
+            .collect();
+        set.len() + 1 //plus the stone we're about to play
+    }
 
     pub fn score(&self) -> Score {
         Score::new(self)

src/board/test/hypotheticals.rs

@@ -0,0 +1,180 @@
+/************************************************************************
+ *                                                                      *
+ * Copyright 2015 Igor Polyakov                                         *
+ *                                                                      *
+ * This file is part of Iomrascálaí.                                    *
+ *                                                                      *
+ * Iomrascálaí is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation, either version 3 of the License, or    *
+ * (at your option) any later version.                                  *
+ *                                                                      *
+ * Iomrascálaí is distributed in the hope that it will be useful,       *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
+ * GNU General Public License for more details.                         *
+ *                                                                      *
+ * You should have received a copy of the GNU General Public License    *
+ * along with Iomrascálaí.  If not, see <http://www.gnu.org/licenses/>. *
+ *                                                                      *
+ ************************************************************************/
+ 
+ #![cfg(test)]
+use std::path::Path;
+use board::Black;
+use board::Coord;
+use board::Pass;
+use board::White;
+use board::movement::Play;
+use sgf::Parser;
+
+#[test]
+fn top_left_has_one_liberty() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(1, board.liberty_count(Coord::new(1,19)));
+}
+
+#[test]
+fn one_below_top_left_has_two_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(2, board.liberty_count(Coord::new(1,18)));
+}
+
+#[test]
+fn two_below_top_left_has_three_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(3, board.liberty_count(Coord::new(1,17)));
+}
+
+#[test]
+fn first_square_surrounded_by_four_liberties_in_top_left() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(4, board.liberty_count(Coord::new(5,16)));
+}
+
+#[test]
+fn removes_one_stone() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(1, board.removes_enemy_neighbouring_stones(Play(Black, 4, 19)));
+}
+
+#[test]
+fn removes_two_stones() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(2, board.removes_enemy_neighbouring_stones(Play(Black, 4, 15)));
+}
+
+#[test]
+fn removes_three_stones() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(3, board.removes_enemy_neighbouring_stones(Play(Black, 4, 10)));
+}
+
+#[test]
+fn removes_four_stones() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(4, board.removes_enemy_neighbouring_stones(Play(Black, 4, 4)));
+}
+
+#[test]
+fn removes_three_neighbours() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(3, board.removes_enemy_neighbouring_stones(Play(Black, 9, 18)));
+}
+
+#[test]
+fn removes_two_neighbours() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    assert_eq!(2, board.removes_enemy_neighbouring_stones(Play(Black, 9, 15)));
+}
+
+#[test]
+fn two_stones_have_six_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    
+    let play = Play(Black, 10, 12);
+    assert_eq!(2, board.new_chain_length(play));
+    assert_eq!(6, board.new_chain_liberties(play));
+}
+
+#[test]
+fn three_stones_have_eight_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    let play = Play(Black, 10, 10);
+    assert_eq!(3, board.new_chain_length(play));
+    assert_eq!(8, board.new_chain_liberties(play));
+}
+
+#[test]
+fn four_stones_have_eight_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    let play = Play(Black, 10, 7);
+    assert_eq!(4, board.new_chain_length(play));
+    assert_eq!(8, board.new_chain_liberties(play));
+}
+
+#[test]
+fn five_stones_have_eight_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    let play = Play(Black, 10, 4);
+    assert_eq!(5, board.new_chain_length(play));
+    assert_eq!(8, board.new_chain_liberties(play));
+}
+
+#[test]
+fn six_stones_have_nine_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    let play = Play(Black, 15, 17);
+    assert_eq!(6, board.new_chain_length(play));
+    assert_eq!(9, board.new_chain_liberties(play));
+}
+
+#[test]
+fn seven_stones_have_ten_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    let play = Play(Black, 15, 13);
+    assert_eq!(7, board.new_chain_length(play));
+    assert_eq!(10, board.new_chain_liberties(play));
+}
+
+#[test]
+fn nine_stones_have_twelve_liberties() {
+    let parser = Parser::from_path(Path::new("fixtures/sgf/hypothetical-plays.sgf"));
+    let game   = parser.game().unwrap();
+    let board  = game.board();
+    let play = Play(Black, 15, 9);
+    assert_eq!(9, board.new_chain_length(play));
+    assert_eq!(12, board.new_chain_liberties(play));
+}

src/board/test/mod.rs

@@ -42,6 +42,7 @@ use std::path::Path;
 mod diagonals;
 mod eye;
 mod ko;
+mod hypotheticals;
 
 #[test]
 fn getting_a_valid_coord_returns_a_color() {

src/config.rs

@@ -37,7 +37,7 @@ impl Config {
     pub fn default() -> Config {
         Config {
             log: false,
-            playout: Box::new(NoEyesPlayout::new()),
+            playout: ::playout::factory(Some(String::from_str("default"))),
             ruleset: Minimal,
             threads: 1,
             uct_expand_after: 1,

src/engine/mc/mod.rs

@@ -125,7 +125,8 @@ 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, Some(&m), &mut rng);
+                let mut b = board.clone();
+                let playout_result = config.playout.run(&mut b, Some(&m), &mut rng);
                 let winner = playout_result.winner();
                 T::record_playout(&mut stats, &playout_result, winner == color);
             }

src/engine/uct/mod.rs

@@ -112,15 +112,13 @@ fn spin_up_worker<'a>(config: Arc<Config>, board: Board, color: Color, send_to_m
                 _ = receive_halt.recv() => { break; },
                 task = receive_from_main.recv() => {
                     let (path, moves, expanded) = task.unwrap();
-                    // TODO: We do a clone here and then one when we
-                    // call run(). One is enough!
                     let mut b = board.clone();
                     for &m in moves.iter() {
                         b.play_legal_move(m);
                     }
                     // Playout is smart enough to correctly handle the
                     // case where the game is already over.
-                    let playout_result = config.playout.run(&b, None, &mut rng);
+                    let playout_result = config.playout.run(&mut b, None, &mut rng);
                     let winner = playout_result.winner();
                     let send_to_self = send_to_self.clone();
                     send_to_main.send(((path, winner), send_to_self));

src/main.rs

@@ -74,7 +74,7 @@ pub fn main() {
     opts.optopt("e", "engine", "select an engine (defaults to amaf)", "amaf|mc|random|uct");
     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|no-eyes-with-pass|simple|simple-with-pass");
+    opts.optopt("p", "playout", "type of playout to use (defaults to light)", "light|no-self-atari");
     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,61 +20,45 @@
  ************************************************************************/
 
 pub use self::no_eyes::NoEyesPlayout;
-pub use self::no_eyes::NoEyesWithPassPlayout;
-pub use self::simple::SimplePlayout;
-pub use self::simple::SimpleWithPassPlayout;
+pub use self::no_eyes::NoSelfAtariPlayout;
 use board::Board;
 use board::Color;
 use board::Move;
 use board::Pass;
 use board::Play;
 
-//use rand::random;
 use rand::{Rng, XorShiftRng};
 
 mod no_eyes;
-mod simple;
 mod test;
 
 pub fn factory(opt: Option<String>) -> Box<Playout> {
-    match opt {
-        Some(s) => {
-            match s.as_ref() {
-                "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())
+    match opt.as_ref().map(::std::ops::Deref::deref) {
+        Some("no-self-atari") => Box::new(NoSelfAtariPlayout),
+        _ => Box::new(NoEyesPlayout),
     }
 }
 
 pub trait Playout: Sync + Send {
 
-    fn run(&self, b: &Board, initial_move: Option<&Move>, rng: &mut XorShiftRng) -> PlayoutResult {
-        let mut board = b.clone();
+    fn run(&self, board: &mut Board, initial_move: Option<&Move>, rng: &mut XorShiftRng) -> PlayoutResult {
         let mut played_moves = Vec::new();
-        match initial_move {
-            Some(&m) => {
-                board.play(m);
-                played_moves.push(m);
-            },
-            None => {}
-        }
+        
+        initial_move.map(|&m| {
+            board.play_legal_move(m);
+            played_moves.push(m);
+        });
+
         let max_moves = self.max_moves(board.size());
-        let mut move_count = 0;
-        while !board.is_game_over() && move_count < max_moves {
+        while !board.is_game_over() && played_moves.len() < max_moves {
             let m = self.select_move(&board, rng);
             board.play_legal_move(m);
             played_moves.push(m);
-            move_count += 1;
         }
         PlayoutResult::new(played_moves, board.winner())
     }
 
     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
@@ -83,20 +67,14 @@ pub trait Playout: Sync + Send {
     fn select_move(&self, board: &Board, rng: &mut XorShiftRng) -> Move {
         let color = board.next_player();
         let vacant = board.vacant();
-        let playable_move =  vacant
+        let playable_move = vacant
             .iter()
             .map(|c| Play(color, c.col, c.row))
             .position(|m| board.is_legal(m).is_ok() && self.is_playable(board, &m));
         if playable_move.is_some() {
             loop {
-                let add = if self.include_pass() {
-                    1
-                } else {
-                    0
-                };
-
                 let first = playable_move.unwrap();
-                let r = first + rng.gen::<usize>() % (vacant.len() + add - first);
+                let r = first + rng.gen::<usize>() % (vacant.len() - first);
                 if r == vacant.len() {
                     return Pass(color);
                 } else {
@@ -116,7 +94,6 @@ pub trait Playout: Sync + Send {
 
 }
 
-#[derive(Debug)]
 pub struct PlayoutResult {
     moves: Vec<Move>,
     winner: Color,