arimaa-engine 0.1.0

A bitboard-based Arimaa game engine: move generation, game state, and Zobrist hashing.
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

use anyhow::anyhow;
use std::fmt;
use std::str::FromStr;

#[derive(Hash, Eq, PartialEq, PartialOrd, Ord, Clone, Copy, Debug)]
pub enum Piece {
    Rabbit,
    Cat,
    Dog,
    Horse,
    Camel,
    Elephant,
}

impl fmt::Display for Piece {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let piece = match self {
            Piece::Elephant => 'e',
            Piece::Camel => 'm',
            Piece::Horse => 'h',
            Piece::Dog => 'd',
            Piece::Cat => 'c',
            Piece::Rabbit => 'r',
        };

        write!(f, "{}", piece)
    }
}

impl FromStr for Piece {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let piece = match s.chars().next() {
            Some(c) if s.len() == 1 => match c {
                'E' | 'e' => Some(Piece::Elephant),
                'M' | 'm' => Some(Piece::Camel),
                'H' | 'h' => Some(Piece::Horse),
                'D' | 'd' => Some(Piece::Dog),
                'C' | 'c' => Some(Piece::Cat),
                'R' | 'r' => Some(Piece::Rabbit),
                _ => None,
            },
            _ => None,
        };

        piece.ok_or_else(|| anyhow!("Invalid value for piece"))
    }
}