Fix warnings and update rand

.gitignore

@@ -1,2 +1,4 @@
 Cargo.lock
 target
+
+**/*~

.rustfmt.toml

@@ -0,0 +1,3 @@
+edition = "2021"
+fn_params_layout = "Compressed"
+use_small_heuristics = "Max"

Cargo.toml

@@ -1,16 +1,32 @@
 [package]
 name = "minimax"
-version = "0.0.2"
-authors = [ "Samuel Fredrickson <samfredrickson@gmail.com>" ]
+version = "0.5.4"
+authors = [ "Eric Roshan-Eisner <eric.d.eisner@gmail.com>", "Samuel Fredrickson <samfredrickson@gmail.com>" ]
 description = "Generic implementations of Minimax."
-documentation = "http://kinghajj.github.io/doc/minimax/"
-repository = "http://github.com/kinghajj/minimax-rs.git"
+documentation = "https://docs.rs/minimax"
+edition = "2021"
+repository = "https://github.com/edre/minimax-rs"
 readme = "README.md"
 keywords = ["ai", "game", "minimax", "negamax"]
 license = "MIT"
 
 [dependencies]
-rand = "0.3.*"
+instant = { version = "0.1", features = ["wasm-bindgen"] }
+rand = "0.9"
+
+[target.'cfg(not(target_arch="wasm32"))'.dependencies]
+num_cpus = "1.0"
+rayon = "^1.5"
+
+[target.'cfg(target_arch="wasm32")'.dependencies]
+getrandom = { version = "0.3", features = ["wasm_js"]}
+
+[dev-dependencies]
+bencher = "0.1.5"
+
+[[bench]]
+name = "negamax"
+harness = false
 
 [profile.test]
 opt-level = 3

README.md

@@ -1,6 +1,8 @@
 # minimax-rs - Generic implementations of Minimax in Rust.
 
-[![Build Status](https://travis-ci.org/kinghajj/minimax-rs.svg?branch=master)](https://travis-ci.org/kinghajj/minimax-rs) [![Crates.io](https://img.shields.io/crates/v/minimax.svg)](https://crates.io/crates/minimax)
+[![Build Status](https://api.travis-ci.com/edre/minimax-rs.svg?branch=master)](https://travis-ci.com/github/edre/minimax-rs)
+[![Crates.io](https://img.shields.io/crates/v/minimax.svg)](https://crates.io/crates/minimax)
+[![Documentation](https://docs.rs/minimax/badge.svg)](https://docs.rs/minimax)
 
 ## About
 
@@ -10,33 +12,15 @@ This library provides interfaces that describe:
 2. methods of evaluating particular game states for a player; and
 3. strategies for choosing moves for a player.
 
-The eventual goal is to have multiple proper strategies, so that any combination
-of evaluators and strategies can be tested against each other. Currently, only
-a basic alpha-beta pruning Negamax strategy is implemented.
+This crate implements multiple different strategies, so that any combination of
+custom evaluators and strategies can be tested against each other. These include
+single- and multi-threaded algorithms using alpha-beta pruning, iterative
+deepening, and transposition tables. There is also a basic implementation of
+multi-threaded Monte Carlo Tree Search, which does not require writing an
+evaluator.
 
 ## Example
 
-The `ttt` module contains an implementation of Tic-Tac-Toe, demonstrating how to
-use the game and evaluation interfaces. `test` shows how to use strategies.
-
-## License
-
-    Copyright (c) 2015 Samuel Fredrickson
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-    THE SOFTWARE.
+The `ttt` and `connect4` modules contain implementations of Tic-Tac-Toe and
+Connect Four, demonstrating how to use the game and evaluation interfaces.
+`test` shows how to use strategies.

benches/negamax.rs

@@ -1,56 +1,47 @@
-#![feature(test)]
+#[macro_use]
+extern crate bencher;
 extern crate minimax;
-extern crate test;
-use test::Bencher;
-use minimax::*;
-
-#[derive(Clone)]
-pub struct Board;
-
-#[derive(Copy, Clone)]
-pub struct Place;
+#[path = "../examples/connect4.rs"]
+mod connect4;
 
-pub struct Eval;
-
-pub struct Noop;
+use bencher::Bencher;
+use minimax::*;
 
-impl Move for Place {
-    type G = Noop;
-    fn apply(&self, _: &mut Board) {
-    }
-    fn undo(&self, _: &mut Board) {
-    }
+fn bench_negamax(b: &mut Bencher) {
+    let board = connect4::Board::default();
+    b.iter(|| {
+        let mut s = Negamax::new(connect4::BasicEvaluator::default(), 5);
+        let m = s.choose_move(&board);
+        assert!(m.is_some());
+    });
 }
 
-impl Game for Noop {
-    type S = Board;
-    type M = Place;
-
-    fn generate_moves(_: &Board, _: Player, ms: &mut [Option<Place>]) -> usize {
-        const NUM_MOVES: usize = 4;
-        for m in ms.iter_mut().take(NUM_MOVES) {
-            *m = Some(Place);
-        }
-        ms[NUM_MOVES] = None;
-        NUM_MOVES
-    }
-
-    fn get_winner(_: &Board) -> Option<Winner> {
-        None
-    }
+fn bench_iterative(b: &mut Bencher) {
+    let board = connect4::Board::default();
+    b.iter(|| {
+        let mut s = IterativeSearch::new(
+            connect4::BasicEvaluator::default(),
+            IterativeOptions::new().with_table_byte_size(32_000),
+        );
+        s.set_max_depth(5);
+        let m = s.choose_move(&board);
+        assert!(m.is_some());
+    });
 }
 
-impl Evaluator for Eval {
-    type G = Noop;
-
-    fn evaluate(_: &Board, _: Option<Winner>) -> Evaluation {
-        Evaluation::Score(0)
-    }
+fn bench_parallel(b: &mut Bencher) {
+    let board = connect4::Board::default();
+    b.iter(|| {
+        let mut s = ParallelSearch::new(
+            connect4::BasicEvaluator::default(),
+            IterativeOptions::new().with_table_byte_size(32_000),
+            ParallelOptions::new(),
+        );
+        s.set_max_depth(5);
+        let m = s.choose_move(&board);
+        assert!(m.is_some());
+    });
 }
 
-#[bench]
-fn bench_negamax(b: &mut Bencher) {
-    let board = Board;
-    let mut s = Negamax::<Eval>::new(Options { max_depth: 10 });
-    b.iter(|| s.choose_move(&board, Player::Computer));
-}
+benchmark_group!(benches, bench_negamax, bench_iterative, bench_parallel);
+benchmark_main!(benches);

examples/chess/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "chess-minimax-example"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+chess = "3.2"
+minimax = { path = "../.." }

examples/chess/src/main.rs

@@ -0,0 +1,82 @@
+extern crate chess;
+extern crate minimax;
+
+use chess::{Board, BoardStatus, ChessMove, MoveGen};
+use minimax::{Game, Strategy};
+
+struct Chess;
+
+impl minimax::Game for Chess {
+    type S = Board;
+    type M = ChessMove;
+
+    fn generate_moves(b: &Board, moves: &mut Vec<ChessMove>) {
+        for m in MoveGen::new_legal(b) {
+            moves.push(m);
+        }
+    }
+
+    fn get_winner(b: &Board) -> Option<minimax::Winner> {
+        match b.status() {
+            BoardStatus::Ongoing => None,
+            BoardStatus::Stalemate => Some(minimax::Winner::Draw),
+            BoardStatus::Checkmate => Some(minimax::Winner::PlayerJustMoved),
+        }
+    }
+
+    fn apply(b: &mut Board, m: ChessMove) -> Option<Board> {
+        Some(b.make_move_new(m))
+    }
+
+    fn zobrist_hash(b: &Board) -> u64 {
+        b.get_hash()
+    }
+
+    fn notation(_b: &Board, m: ChessMove) -> Option<String> {
+        Some(format!("{}", m))
+    }
+}
+
+#[derive(Default)]
+struct Evaluator;
+
+impl minimax::Evaluator for Evaluator {
+    type G = Chess;
+    fn evaluate(&self, board: &Board) -> minimax::Evaluation {
+        let mut score = 0;
+        for sq in 0..64 {
+            let sq = unsafe { chess::Square::new(sq) };
+            if let Some(piece) = board.piece_on(sq) {
+                let value = match piece {
+                    chess::Piece::Pawn => 1,
+                    chess::Piece::Knight => 3,
+                    chess::Piece::Bishop => 3,
+                    chess::Piece::Rook => 5,
+                    chess::Piece::Queen => 9,
+                    chess::Piece::King => 0,
+                };
+                if board.color_on(sq).unwrap() == board.side_to_move() {
+                    score += value;
+                } else {
+                    score -= value;
+                }
+            }
+        }
+        score
+    }
+}
+
+fn main() {
+    let mut b = Board::default();
+    let opts = minimax::IterativeOptions::new().verbose();
+    let mut strategy = minimax::IterativeSearch::new(Evaluator::default(), opts);
+    strategy.set_timeout(std::time::Duration::from_secs(1));
+    while Chess::get_winner(&b).is_none() {
+        println!("{}", b);
+        match strategy.choose_move(&b) {
+            Some(m) => b = Chess::apply(&mut b, m).unwrap(),
+            None => break,
+        }
+    }
+    println!("Checkmate {:?}", b.side_to_move());
+}