Merge pull request #132 from iopq/playout

Remerging the pull request

Author: iopq

src/board/mod.rs

@@ -560,7 +560,8 @@ impl Board {
     fn remove_stone(&mut self, c: Coord) {
         // Resetting the chain_id is not strictly necessary, but will
         // make debugging easier.
-        self.board[c.to_index(self.size)].chain_id = -1;
+        //self.board[c.to_index(self.size)].chain_id = -1;
+        //removed because compiler error
         self.board[c.to_index(self.size)].color = Empty;
     }
 
@@ -594,6 +595,26 @@ impl Board {
         set.len() - 1 //minus the stone we're about to play
     }
 
+    pub fn new_chain_liberties_greater_than(&self, m: Move, limit: usize) -> bool {
+        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);
+            }
+            
+            if set.len() - 1 > limit {
+                return true;
+            }
+        };
+        false
+    }
+    
     //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()
@@ -602,6 +623,23 @@ impl Board {
             .collect();
         set.len() + 1 //plus the stone we're about to play
     }
+    
+    pub fn new_chain_length_less_than(&self, m: Move, limit: usize) -> bool {
+        let mut set: HashSet<&Coord> = HashSet::new();
+        
+        for &c in self.neighbours(m.coord()).iter() {
+            if self.color(&c) == *m.color() {
+                for coord in self.get_chain(c).unwrap().coords().iter() {
+                    set.insert(coord);
+                    if set.len() + 1 > limit {
+                        return false;
+                    }
+                }
+            }
+        }
+        
+        true
+    }
 
     pub fn score(&self) -> Score {
         Score::new(self)

src/board/movement/mod.rs

@@ -27,7 +27,7 @@ use board::Coord;
 
 mod test;
 
-#[derive(Debug, Eq, PartialEq, Hash, Copy)]
+#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]
 pub enum Move {
     Pass(Color),
     Play(Color, u8, u8),

src/board/test/hypotheticals.rs

@@ -116,7 +116,9 @@ fn two_stones_have_six_liberties() {
 
     let play = Play(Black, 10, 12);
     assert_eq!(2, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 3));
     assert_eq!(6, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 5));
 }
 
 #[test]
@@ -126,7 +128,9 @@ fn three_stones_have_eight_liberties() {
     let board  = game.board();
     let play = Play(Black, 10, 10);
     assert_eq!(3, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 4));
     assert_eq!(8, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 7));
 }
 
 #[test]
@@ -136,7 +140,9 @@ fn four_stones_have_eight_liberties() {
     let board  = game.board();
     let play = Play(Black, 10, 7);
     assert_eq!(4, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 5));
     assert_eq!(8, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 7));
 }
 
 #[test]
@@ -146,7 +152,9 @@ fn five_stones_have_eight_liberties() {
     let board  = game.board();
     let play = Play(Black, 10, 4);
     assert_eq!(5, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 6));
     assert_eq!(8, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 7));
 }
 
 #[test]
@@ -156,7 +164,9 @@ fn six_stones_have_nine_liberties() {
     let board  = game.board();
     let play = Play(Black, 15, 17);
     assert_eq!(6, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 7));
     assert_eq!(9, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 8));
 }
 
 #[test]
@@ -165,8 +175,11 @@ fn seven_stones_have_ten_liberties() {
     let game   = parser.game().unwrap();
     let board  = game.board();
     let play = Play(Black, 15, 13);
+
     assert_eq!(7, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 8));
     assert_eq!(10, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 9));
 }
 
 #[test]
@@ -176,5 +189,7 @@ fn nine_stones_have_twelve_liberties() {
     let board  = game.board();
     let play = Play(Black, 15, 9);
     assert_eq!(9, board.new_chain_length(play));
+    assert!(board.new_chain_length_less_than(play, 10));
     assert_eq!(12, board.new_chain_liberties(play));
+    assert!(board.new_chain_liberties_greater_than(play, 11));
 }

src/engine/mc/amaf.rs

@@ -62,9 +62,9 @@ impl McEngine for AmafMcEngine {
     fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {
         for m in playout.moves().iter() {
             if won {
-                stats.record_win(&m);
+                stats.record_win(*m);
             } else {
-                stats.record_loss(&m);
+                stats.record_loss(*m);
             }
         }
     }

src/engine/mc/mod.rs

@@ -103,7 +103,7 @@ fn finish(color: Color, game: &Game, stats: MoveStats, sender: Sender<Move>, hal
     }
 }
 
-fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Move>, game: &Game, send_result: Sender<(MoveStats<'a>, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {
+fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Move>, game: &Game, send_result: Sender<(MoveStats, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {
     let mut guards = Vec::new();
     let mut halt_senders = Vec::new();
     for _ in 0..config.threads {
@@ -117,7 +117,7 @@ fn spin_up<'a, T: McEngine>(color: Color, config: Arc<Config>, moves: &'a Vec<Mo
     (guards, halt_senders)
 }
 
-fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, config: Arc<Config>, send_result: Sender<(MoveStats<'a>, usize)>) -> thread::JoinGuard<'a, ()> {
+fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, config: Arc<Config>, send_result: Sender<(MoveStats, usize)>) -> thread::JoinGuard<'a, ()> {
     thread::scoped(move || {
         let runs = 100;
         let mut rng = weak_rng();

src/engine/mc/simple.rs

@@ -62,9 +62,9 @@ impl McEngine for SimpleMcEngine {
     fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {
         let m = playout.moves()[0];
         if won {
-            stats.record_win(&m);
+            stats.record_win(m);
         } else {
-            stats.record_loss(&m);
+            stats.record_loss(m);
         }
     }
 

src/engine/move_stats/mod.rs

@@ -28,16 +28,16 @@ use std::collections::HashMap;
 
 mod test;
 
-pub struct MoveStats<'a> {
+pub struct MoveStats {
     color: Color,
-    stats: HashMap<&'a Move, MoveStat>,
+    stats: HashMap<Move, MoveStat>,
 }
 
-impl<'a> MoveStats<'a> {
+impl MoveStats {
 
     pub fn new(moves: &Vec<Move>, color: Color) -> MoveStats {
         let mut stats = HashMap::new();
-        for m in moves.iter() {
+        for &m in moves.iter() {
             stats.insert(m, MoveStat::new());
         }
         MoveStats {
@@ -46,14 +46,14 @@ impl<'a> MoveStats<'a> {
         }
     }
 
-    pub fn record_win(&mut self, m: &Move) {
+    pub fn record_win(&mut self, m: Move) {
         match self.stats.get_mut(&m) {
             Some(stat) => stat.won(),
             None       => {}
         }
     }
 
-    pub fn record_loss(&mut self, m: &Move) {
+    pub fn record_loss(&mut self, m: Move) {
         match self.stats.get_mut(&m) {
             Some(stat) => stat.lost(),
             None       => {}
@@ -73,7 +73,7 @@ impl<'a> MoveStats<'a> {
         let mut move_stats = MoveStat::new();
         for (m_new, ms) in self.stats.iter() {
             if ms.win_ratio() > move_stats.win_ratio() {
-                m = **m_new;
+                m = *m_new;
                 move_stats = *ms;
             }
         }
@@ -92,7 +92,7 @@ impl<'a> MoveStats<'a> {
 }
 
 
-#[derive(Copy)]
+#[derive(Copy, Clone)]
 pub struct MoveStat {
     wins: usize,
     plays: usize

src/engine/move_stats/test.rs

@@ -45,10 +45,10 @@ mod move_stats {
     fn returns_the_best_move() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
-        stats.record_loss(&Play(Black, 1, 1));
-        stats.record_win(&Play(Black, 2, 2));
-        stats.record_win(&Play(Black, 2, 2));
+        stats.record_win(Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 1, 1));
+        stats.record_win(Play(Black, 2, 2));
+        stats.record_win(Play(Black, 2, 2));
         let (m, ms) = stats.best();
         assert_eq!(Play(Black, 2, 2), m);
         assert_eq!(ms.plays, 2);
@@ -59,58 +59,58 @@ mod move_stats {
     fn all_wins_returns_true_when_no_losses_were_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
-        stats.record_win(&Play(Black, 2, 2));
+        stats.record_win(Play(Black, 1, 1));
+        stats.record_win(Play(Black, 2, 2));
         assert!(stats.all_wins());
     }
 
     #[test]
     fn all_wins_returns_false_when_a_loss_was_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(&Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 1, 1));
         assert!(!stats.all_wins());
     }
 
     #[test]
     fn all_losses_returns_true_when_no_wins_were_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(&Play(Black, 1, 1));
-        stats.record_loss(&Play(Black, 2, 2));
+        stats.record_loss(Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 2, 2));
         assert!(stats.all_losses());
     }
 
     #[test]
     fn all_losses_returns_false_when_a_win_was_recorded() {
         let moves = vec![Play(Black, 1, 1), Play(Black, 2, 2)];
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
+        stats.record_win(Play(Black, 1, 1));
         assert!(!stats.all_losses());
     }
 
     #[test]
     fn record_win_does_nothing_for_untracked_moves() {
         let moves = vec!();
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&Play(Black, 1, 1));
+        stats.record_win(Play(Black, 1, 1));
     }
 
     #[test]
     fn record_loss_does_nothing_for_untracked_moves() {
         let moves = vec!();
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_loss(&Play(Black, 1, 1));
+        stats.record_loss(Play(Black, 1, 1));
     }
 
     #[test]
     fn merge_merges_stats_existing_in_both() {
         let m = Play(Black, 1, 1);
         let moves = vec!(m);
         let mut stats = MoveStats::new(&moves, Black);
-        stats.record_win(&m);
+        stats.record_win(m);
         let mut other = MoveStats::new(&moves, Black);
-        other.record_loss(&m);
+        other.record_loss(m);
         stats.merge(&other);
         let ms = stats.stats.get(&m).unwrap();
         assert_eq!(ms.wins, 1);
@@ -124,7 +124,7 @@ mod move_stats {
         let mut stats = MoveStats::new(&moves, Black);
         let moves2 = vec!(m);
         let mut other = MoveStats::new(&moves2, Black);
-        other.record_loss(&m);
+        other.record_loss(m);
         stats.merge(&other);
         assert!(!stats.stats.get(&m).is_some());
     }

src/playout/no_eyes.rs

@@ -45,19 +45,20 @@ impl Playout for NoSelfAtariPlayout {
 
     fn is_playable(&self, board: &Board, m: &Move) -> bool {
         !board.is_eye(&m.coord(), *m.color())
-        && (
-            board.liberty_count(m.coord()) > 1 ||
+        && {
+            let empty = board.liberty_count(m.coord());
+            empty > 1 ||
             {
                 let removed_enemies = board.removes_enemy_neighbouring_stones(*m);
 
-                removed_enemies > 1 ||
+                empty + removed_enemies > 1 ||
                 {
-                let liberties = board.new_chain_liberties(*m);
-                liberties + removed_enemies > 1
+                (removed_enemies > 0 && board.new_chain_liberties_greater_than(*m, 0)) ||
+                board.new_chain_liberties_greater_than(*m, 1)
                 }
-            } 
-            || board.new_chain_length(*m) < 3 //don't suicide 3 stone groups in the playouts, only in the tree
-        )
+            }
+            || board.new_chain_length_less_than(*m, 3) //you can self-atari one or two stones in playouts
+        }
     }
 
     fn playout_type(&self) -> String {