chess-notation-parser 0.2.2

Algebraic chess notation parser
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

# Chess notation parser
Crate transforms algebraic chess notation into software readable structs and
vice versa. Parsed chess notation for each turn is stored within `Turn`
struct.

To parse a certain chess turn, such as `d2xe3`, store it in form of `&str` and
pass it as an argument into `Turn::try_from()` function.

`Turn` is an enum with two elements:
- `Castling` - a struct which describes *castling* turn
- `Move` - a struct which describes every other possible turn

## Example for `Castling` turn
#### `0-0` will be translated to:
```rust
Turn::Castling(Castling {
    r#type: CastlingType::Short,
    flags: Flag::NONE,
});
```

## Examples for `Move` turns
#### `d6` will be translated to:
```rust
Turn::Move (Move {
    who: Piece::Pawn,
    dst: Square::D6,
    flags: Flag::NONE,
    src: None,
    promotion: None,
});
```

#### `d7xe8=B+?` will be translated to:
```rust
Turn::Move (Move {
    who: Piece::Pawn,
    dst: Square::E8,
    flags: Flag::CHECK | Flag::CAPTURE,
    src: Some(vec![Square::D7]),
    promotion: Some(Piece::Bishop),
});
```

#### `Nab3#` will be translated to:
```rust
Turn::Move (Move {
    who: Piece::Knight,
    dst: Square::B3,
    flags: Flag::CHECKMATE,
    src: Some(Square::get_file('a').unwrap()),  // Vector of 'Ax' squares
    promotion: None,
});
```

# Chess notation parser rules
- **Square notation** should use lowercase alphabetic characters
  - Valid: `a1`, `a2` ... `h7`, `h8`.

- **Castling notation** can be written with both `0` and `O`
  - Valid example: `0-0-0` or `O-O`
  - When `Castling` turn is printed out, it will be printed with `0`
  notation

- Notation for **pieces**:
  - `K`: King
  - `Q`: Queen
  - `R`: Rook
  - `B`: Bishop
  - `N`: Knight
  - Pawns are indicated by the absence of the letter

- **Capture** is annotated with a lowercase `x` character
  - Valid example: `Qxd3`

- **Check** is annotated with a `+` character
  - Valid example: `Qd3+`

- **Checkmate** is annotated with a `#` character
  - Valid example: `Qd3#`

- **Pawn promotion** is annoted with `=` symbol followed by a piece to which
  pawn is promoted to
  - Pawn promotion is valid only for ranks `8` and `1`
  - Valid example: `g8=Q`

- Comments `??`, `!!`, `?`, `!`, `!?`, `?!` are allowed only at the end of
the turn
  - Valid example: `a1=B??`
  - Invalid example: `??a1=B`

# About
I don't really play chess that much, but I needed something to practice my Rust
skills, so this was sort of a fun project.
This particular crate was created for the purpose of [Pacifist chess
simulation](https://github.com/Rqnsom/pacifist-chess-simulation).