chessrs 0.1.0

A command line implementation for the game of 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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::fmt::Display;

use crate::PieceType;

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Coords {
    pub piece: PieceType,
    pub is_capture: bool,
    pub x: usize,
    pub y: usize,
}

impl Display for Coords {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let x = (self.x as u8 + 'a' as u8) as char;
        let y = (self.y as u8 + '1' as u8) as char;

        write!(f, "{}{}", x, y)
    }
}

impl Into<(usize, usize)> for Coords {
    fn into(self) -> (usize, usize) {
        (self.x, self.y)
    }
}

impl From<(usize, usize)> for Coords {
    fn from(tuple: (usize, usize)) -> Self {
        Coords {
            piece: PieceType::None,
            is_capture: false,
            x: tuple.0,
            y: 7 - tuple.1,
        }
    }
}

impl Coords {
    pub fn new(x: usize, y: usize) -> Self {
        Coords {
            piece: PieceType::None,
            is_capture: false,
            x,
            y: 7 - y,
        }
    }
    pub fn from_raw(x: usize, y: usize) -> Self {
        Coords {
            piece: PieceType::None,
            is_capture: false,
            x,
            y,
        }
    }

    pub fn build(s: &str) -> Result<Coords, String> {
        if s.len() > 4 || s.len() < 2 {
            return Err("Invalid input".to_string());
        }

        let mut chars = s.chars();
        let piece = if s.len() == 2 {
            PieceType::Pawn
        } else {
            match chars.next().unwrap() {
                'p' => PieceType::Pawn,
                'r' => PieceType::Rook,
                'n' => PieceType::Knight,
                'b' => PieceType::Bishop,
                'q' => PieceType::Queen,
                'k' => PieceType::King,
                _ => return Err("Invalid piece".to_string()),
            }
        };
        let is_capture = if s.len() > 3 {
            match chars.next().unwrap() {
                'x' => true,
                _ => false,
            }
        } else {
            false
        };
        let x = match chars.next().unwrap() {
            x @ 'a'..='h' => x as usize - 'a' as usize,
            _ => return Err("Invalid x coordinate".to_string()),
        };
        let y = match chars.next().unwrap() {
            y @ '1'..='8' => y as usize - '1' as usize,
            _ => return Err("Invalid y coordinate".to_string()),
        };

        Ok(Coords {
            piece,
            is_capture,
            x,
            y,
        })
    }

    pub fn default() -> Self {
        Coords {
            piece: PieceType::None,
            is_capture: false,
            x: 9,
            y: 9,
        }
    }
}