ruchess 0.0.7

rust chess
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//! perft divide — prints the number of leaf nodes per root move at a given depth.
//!
//! Usage:
//!     cargo run --release --example perft_divide -- "<FEN>" <depth>

use ruchess::{fen, mve::Move, position::Position};

fn perft(pos: &mut Position, depth: u32) -> u64 {
    if depth == 0 {
        return 1;
    }
    if depth == 1 {
        return pos.valid_moves().count() as u64;
    }
    let moves: Vec<Move> = pos.valid_moves().collect();
    let mut total: u64 = 0;
    for m in moves {
        let undo = pos.make(&m);
        total += perft(pos, depth - 1);
        pos.unmake(undo);
    }
    total
}

fn fmt_move(m: &ruchess::mve::Move) -> String {
    let promo = match m.promotion {
        Some(p) => format!("{}", p.as_ascii()),
        None => String::new(),
    };
    format!("{}{}{}", m.orig, m.dest, promo)
}

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    if args.len() < 2 {
        eprintln!("usage: perft_divide <FEN> <depth>");
        std::process::exit(2);
    }
    let fen_str = &args[0];
    let depth: u32 = args[1].parse().expect("depth must be a number");

    let pos = fen::parse(fen_str)
        .expect("FEN should parse")
        .without_repetition();

    let moves: Vec<Move> = pos.valid_moves().collect();
    let mut rows: Vec<(String, u64)> = moves
        .into_iter()
        .map(|m| {
            let mut working = pos.clone();
            let undo = working.make(&m);
            let count = if depth == 0 {
                1
            } else {
                perft(&mut working, depth - 1)
            };
            working.unmake(undo);
            (fmt_move(&m), count)
        })
        .collect();
    rows.sort_by(|a, b| a.0.cmp(&b.0));

    let mut total: u64 = 0;
    for (mv, n) in &rows {
        println!("{mv}: {n}");
        total += n;
    }
    println!("\nmoves: {}", rows.len());
    println!("total: {total}");
}