rsshogi 1.0.2

Reusable Rust shogi primitives for board state, move generation, legality, and record parsing.
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

use std::collections::BTreeSet;

use serde::Deserialize;

use rsshogi::board::{self, MoveList, NonEvasionsAll, generate_moves};

#[test]
fn test_startpos_generates_all_legal_moves() {
    let pos = board::hirate_position();
    let mut moves = MoveList::new();

    generate_moves::<NonEvasionsAll>(&pos, &mut moves);

    let legal: Vec<_> = moves
        .iter()
        .copied()
        .filter(|&mv| {
            let mv_move = pos.move32_from_move(mv);
            mv_move.is_normal() && pos.is_legal_move32(mv_move)
        })
        .collect();
    assert_eq!(legal.len(), 30, "startpos must yield 30 legal moves");

    let unique: BTreeSet<String> = legal.iter().map(|mv| mv.to_usi()).collect();
    assert_eq!(unique.len(), legal.len(), "generated moves must be unique");
}

#[derive(Deserialize)]
struct LegalFixture {
    sfen: String,
    moves: Vec<String>,
}

#[test]
fn test_yaneuraou_snapshots_match_generated_legal_moves() {
    let fixtures: std::collections::BTreeMap<String, LegalFixture> =
        serde_json::from_str(include_str!("test_data/yaneuraou_legal_moves.json"))
            .expect("valid move fixture json");

    for (name, fixture) in fixtures {
        let pos = board::position_from_sfen(&fixture.sfen).expect("parse sfen");
        let mut moves = MoveList::new();
        generate_moves::<NonEvasionsAll>(&pos, &mut moves);

        let mut generated: Vec<String> = moves
            .iter()
            .copied()
            .filter(|&mv| {
                let mv_move = pos.move32_from_move(mv);
                mv_move.is_normal() && pos.is_legal_move32(mv_move)
            })
            .map(rsshogi::types::Move::to_usi)
            .collect();
        generated.sort();

        let mut expected = fixture.moves.clone();
        expected.sort();

        assert_eq!(generated, expected, "legal move mismatch for {name}");

        assert!(!generated.is_empty(), "fixture {name}: legal move list must not be empty");
    }
}