Merge pull request #120 from ujh/two-kinds-of-playouts

Four kinds of playouts

Author: ujh

src/board/mod.rs

@@ -19,6 +19,7 @@
  * along with Iomrascálaí.  If not, see <http://www.gnu.org/licenses/>. *
  *                                                                      *
  ************************************************************************/
+
 pub use self::Color::Black;
 pub use self::Color::Empty;
 pub use self::Color::White;
@@ -28,22 +29,22 @@ pub use self::movement::Move;
 pub use self::movement::Pass;
 pub use self::movement::Play;
 pub use self::movement::Resign;
-use rand::{Rng, XorShiftRng};
 use ruleset::Ruleset;
 use score::Score;
 use self::point::Point;
 
-use std::sync::Arc;
+use rand::Rng;
+use rand::XorShiftRng;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt;
-use std::vec::Vec;
+use std::sync::Arc;
 
-mod test;
 mod chain;
 mod coord;
 mod movement;
 mod point;
+mod test;
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum IllegalMove {
@@ -262,63 +263,7 @@ impl Board {
                 .collect()
         }
     }
-    
-    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.playout_legal_move(m) ) {
-                    //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.playout_legal_move(random_play) {
-                            return random_play;
-                        } 
-                    }
-                } else {
-                    let color = self.next_player();
-                    Pass(color)
-                }
-	}
-    
-    fn playout_legal_move(&self, m: Move) -> bool {
-    	        // Can't play on a Ko point
-        if self.ko.is_some() && m.coord() == self.ko.unwrap() {
-            if self.neighbours(m.coord()) //neighbours of the coordinate of the ko point
-                .iter()
-                .filter(|&c| self.color(c) == m.color().opposite()) //accept coordinates of opposite stones
-                .map(|&c| self.get_chain(c).unwrap()) //get the chain of those opposite stones
-                .any(|chain| chain.liberties().len() == 1 && chain.coords().len() == 1) { //if any of them has one liberty and one stone
-                    return false;
-                }
-        }
-        // Can't play suicide move
-        if !self.ruleset.suicide_allowed() {
-            // All neighbours must be occupied
-            if self.neighbours(m.coord()).iter().all(|c| self.color(c) != Empty) {
-                // A move is a suicide move if all of the opposing,
-                // neighbouring chain has more than one liberty and all of
-                // our own chains have only one liberty.
-                let enemy_chains_with_other_libs = self.neighbours(m.coord())
-                    .iter()
-                    .filter(|&c| self.color(c) == m.color().opposite())
-                    .all(|&c| self.get_chain(c).unwrap().liberties().len() > 1);
-                let own_chains_without_other_libs = self.neighbours(m.coord())
-                    .iter()
-                    .filter(|&c| self.color(c) == *m.color())
-                    .all(|&c| self.get_chain(c).unwrap().liberties().len() <= 1);
-                if enemy_chains_with_other_libs && own_chains_without_other_libs {
-                    return false;
-                }
-            }
-        }
-        
-        true
-	}
-    
+
     //#[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

@@ -22,7 +22,6 @@
 
 #![cfg(test)]
 #![allow(unused_must_use)]
-use std::path::Path;
 use board::Black;
 use board::Board;
 use board::Coord;
@@ -36,8 +35,9 @@ use ruleset::AnySizeTrompTaylor;
 use ruleset::KgsChinese;
 use ruleset::Minimal;
 use sgf::Parser;
-use rand::{Rng, weak_rng};
-use test::Bencher;
+
+use rand::weak_rng;
+use std::path::Path;
 
 mod diagonals;
 mod eye;
@@ -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 mut board  = game.board();
-    let mut rng = weak_rng();
-    for i in 0..10 {
-    	let m = board.playout_move(&mut rng);
-    	assert!(board.is_legal(m).is_ok());
-	}
-}

src/config.rs

@@ -19,12 +19,14 @@
  *                                                                      *
  ************************************************************************/
 
+use playout::Playout;
+use playout::SimplePlayout;
 use ruleset::Minimal;
 use ruleset::Ruleset;
 
-#[derive(Copy)]
 pub struct Config {
     pub log: bool,
+    pub playout: Box<Playout>,
     pub ruleset: Ruleset,
     pub threads: usize,
 }
@@ -34,6 +36,7 @@ impl Config {
     pub fn default() -> Config {
         Config {
             log: false,
+            playout: Box::new(SimplePlayout::new()),
             ruleset: Minimal,
             threads: 1,
         }

src/engine/controller/mod.rs

@@ -28,20 +28,21 @@ use timer::Timer;
 use std::old_io::Writer;
 
 use std::old_io::timer::sleep;
+use std::sync::Arc;
 use std::sync::mpsc::channel;
 use std::thread;
 use std::time::duration::Duration;
 
 mod test;
 
 pub struct EngineController<'a> {
-    config: Config,
+    config: Arc<Config>,
     engine: Box<Engine + 'a>,
 }
 
 impl<'a> EngineController<'a> {
 
-    pub fn new<'b>(config: Config, engine: Box<Engine + 'b>) -> EngineController<'b> {
+    pub fn new<'b>(config: Arc<Config>, engine: Box<Engine + 'b>) -> EngineController<'b> {
         EngineController {
             config: config,
             engine: engine,

src/engine/controller/test.rs

@@ -32,6 +32,7 @@ use ruleset::Minimal;
 use super::EngineController;
 use timer::Timer;
 
+use std::sync::Arc;
 use std::sync::mpsc::Receiver;
 use std::sync::mpsc::Sender;
 use time::PreciseTime;
@@ -61,7 +62,7 @@ fn the_engine_can_use_less_time_than_allocated() {
     let mut timer = Timer::new();
     let budget = timer.budget(&game);
     let engine = Box::new(EarlyReturnEngine::new());
-    let mut controller = EngineController::new(Config::default(), engine);
+    let mut controller = EngineController::new(Arc::new(Config::default()), engine);
     let start_time = PreciseTime::now();
     let m = controller.run_and_return_move(color, &game, &mut timer);
     let elapsed_time = start_time.to(PreciseTime::now()).num_milliseconds();
@@ -97,7 +98,7 @@ fn the_controller_asks_the_engine_for_a_move_when_the_time_is_up() {
     timer.setup(1, 0, 0);
     let budget = timer.budget(&game);
     let engine = Box::new(WaitingEngine::new());
-    let mut controller = EngineController::new(Config::default(), engine);
+    let mut controller = EngineController::new(Arc::new(Config::default()), engine);
     let start_time = PreciseTime::now();
     let m = controller.run_and_return_move(color, &game, &mut timer);
     let elapsed_time = start_time.to(PreciseTime::now()).num_milliseconds();

src/engine/mc/amaf.rs

@@ -24,21 +24,22 @@ use board::Color;
 use board::Move;
 use config::Config;
 use game::Game;
-use playout::Playout;
+use playout::PlayoutResult;
 use super::Engine;
 use super::McEngine;
 use super::MoveStats;
 
+use std::sync::Arc;
 use std::sync::mpsc::Receiver;
 use std::sync::mpsc::Sender;
 
 pub struct AmafMcEngine {
-    config: Config
+    config: Arc<Config>
 }
 
 impl AmafMcEngine {
 
-    pub fn new(config: Config) -> AmafMcEngine {
+    pub fn new(config: Arc<Config>) -> AmafMcEngine {
         AmafMcEngine { config: config }
     }
 
@@ -47,14 +48,18 @@ impl AmafMcEngine {
 impl Engine for AmafMcEngine {
 
     fn gen_move(&self, color: Color, game: &Game, sender: Sender<Move>, receiver: Receiver<()>) {
-        super::gen_move::<AmafMcEngine>(self.config, color, game, sender, receiver);
+        super::gen_move::<AmafMcEngine>(self.config.clone(), color, game, sender, receiver);
+    }
+
+    fn engine_type(&self) -> &'static str {
+        "amaf"
     }
 
 }
 
 impl McEngine for AmafMcEngine {
 
-    fn record_playout(stats: &mut MoveStats, playout: &Playout, won: bool) {
+    fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {
         for m in playout.moves().iter() {
             if won {
                 stats.record_win(&m);

src/engine/mc/mod.rs

@@ -32,10 +32,13 @@ use board::Resign;
 use config::Config;
 use game::Game;
 use playout::Playout;
-use std::old_io::Writer;
+use playout::PlayoutResult;
 
-use rand::{Rng, weak_rng};
+use rand::Rng;
+use rand::weak_rng;
 use std::marker::MarkerTrait;
+use std::old_io::Writer;
+use std::sync::Arc;
 use std::sync::mpsc::Receiver;
 use std::sync::mpsc::Sender;
 use std::sync::mpsc::channel;
@@ -46,11 +49,11 @@ mod simple;
 
 pub trait McEngine: MarkerTrait {
 
-    fn record_playout(&mut MoveStats, &Playout, bool);
+    fn record_playout(&mut MoveStats, &PlayoutResult, bool);
 
 }
 
-fn gen_move<T: McEngine>(config: Config, color: Color, game: &Game, sender: Sender<Move>, receiver: Receiver<()>) {
+fn gen_move<T: McEngine>(config: Arc<Config>, color: Color, game: &Game, sender: Sender<Move>, receiver: Receiver<()>) {
     let moves = game.legal_moves_without_eyes();
     if moves.is_empty() {
         if config.log {
@@ -62,7 +65,7 @@ fn gen_move<T: McEngine>(config: Config, color: Color, game: &Game, sender: Send
     let mut stats = MoveStats::new(&moves, color);
     let mut counter = 0;
     let (send_result, receive_result) = channel::<(MoveStats, usize)>();
-    let (guards, halt_senders) = spin_up::<T>(color, config.threads, &moves, game, send_result);
+    let (guards, halt_senders) = spin_up::<T>(color, config.clone(), &moves, game, send_result);
     loop {
         select!(
             result = receive_result.recv() => {
@@ -100,30 +103,31 @@ fn finish(color: Color, game: &Game, stats: MoveStats, sender: Sender<Move>, hal
     }
 }
 
-fn spin_up<'a, T: McEngine>(color: Color, threads: usize, 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<'a>, usize)>) -> (Vec<thread::JoinGuard<'a, ()>>, Vec<Sender<()>>) {
     let mut guards = Vec::new();
     let mut halt_senders = Vec::new();
-    for _ in 0..threads {
+    for _ in 0..config.threads {
         let (send_halt, receive_halt) = channel::<()>();
         halt_senders.push(send_halt);
         let send_result = send_result.clone();
-        let guard = spin_up_worker::<T>(color, receive_halt, moves, game.board(), send_result);
+        let config = config.clone();
+        let guard = spin_up_worker::<T>(color, receive_halt, moves, game.board(), config, send_result);
         guards.push(guard);
     }
     (guards, halt_senders)
 }
 
-fn spin_up_worker<'a, T: McEngine>(color: Color, recv_halt: Receiver<()>, moves: &'a Vec<Move>, board: Board, 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<'a>, usize)>) -> thread::JoinGuard<'a, ()> {
     thread::scoped(move || {
         let runs = 100;
         let mut rng = weak_rng();
         let mut stats = MoveStats::new(moves, color);
         loop {
             for _ in 0..runs {
                 let m = moves[rng.gen::<usize>() % moves.len()];
-                let playout = Playout::run(&board, &m, &mut rng);
-                let winner = playout.winner();
-                T::record_playout(&mut stats, &playout, winner == color);
+                let playout_result = config.playout.run(&board, &m);
+                let winner = playout_result.winner();
+                T::record_playout(&mut stats, &playout_result, winner == color);
             }
             if recv_halt.try_recv().is_ok() {
                 break;

src/engine/mc/simple.rs

@@ -24,35 +24,42 @@ use board::Color;
 use board::Move;
 use config::Config;
 use game::Game;
-use playout::Playout;
+use playout::PlayoutResult;
 use super::Engine;
 use super::McEngine;
 use super::MoveStats;
 
+use std::sync::Arc;
 use std::sync::mpsc::Receiver;
 use std::sync::mpsc::Sender;
 
 pub struct SimpleMcEngine {
-    config: Config
+    config: Arc<Config>
 }
 
 impl SimpleMcEngine {
 
-    pub fn new(config: Config) -> SimpleMcEngine {
+    pub fn new(config: Arc<Config>) -> SimpleMcEngine {
         SimpleMcEngine { config: config }
     }
 
 }
 
 impl Engine for SimpleMcEngine {
+
     fn gen_move(&self, color: Color, game: &Game, sender: Sender<Move>, receiver: Receiver<()>) {
-        super::gen_move::<SimpleMcEngine>(self.config, color, game, sender, receiver);
+        super::gen_move::<SimpleMcEngine>(self.config.clone(), color, game, sender, receiver);
+    }
+
+    fn engine_type(&self) -> &'static str {
+        "simple-mc"
     }
+
 }
 
 impl McEngine for SimpleMcEngine {
 
-    fn record_playout(stats: &mut MoveStats, playout: &Playout, won: bool) {
+    fn record_playout(stats: &mut MoveStats, playout: &PlayoutResult, won: bool) {
         let m = playout.moves()[0];
         if won {
             stats.record_win(&m);